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
139
frontend/node_modules/@jest/transform/build/index.d.mts
generated
vendored
Normal file
139
frontend/node_modules/@jest/transform/build/index.d.mts
generated
vendored
Normal file
@@ -0,0 +1,139 @@
|
||||
import { Config, TransformTypes } from "@jest/types";
|
||||
import { EncodedSourceMap } from "@jridgewell/trace-mapping";
|
||||
|
||||
//#region src/types.d.ts
|
||||
|
||||
interface ShouldInstrumentOptions extends Pick<Config.GlobalConfig, 'collectCoverage' | 'collectCoverageFrom' | 'coverageProvider'> {
|
||||
changedFiles?: Set<string>;
|
||||
sourcesRelatedToTestsInChangedFiles?: Set<string>;
|
||||
}
|
||||
interface Options extends ShouldInstrumentOptions, CallerTransformOptions {
|
||||
isInternalModule?: boolean;
|
||||
}
|
||||
interface FixedRawSourceMap extends Omit<EncodedSourceMap, 'version'> {
|
||||
version: number;
|
||||
}
|
||||
type TransformedSource = {
|
||||
code: string;
|
||||
map?: FixedRawSourceMap | string | null;
|
||||
};
|
||||
type TransformResult = TransformTypes.TransformResult;
|
||||
interface CallerTransformOptions {
|
||||
supportsDynamicImport: boolean;
|
||||
supportsExportNamespaceFrom: boolean;
|
||||
supportsStaticESM: boolean;
|
||||
supportsTopLevelAwait: boolean;
|
||||
}
|
||||
interface ReducedTransformOptions extends CallerTransformOptions {
|
||||
instrument: boolean;
|
||||
}
|
||||
interface RequireAndTranspileModuleOptions extends ReducedTransformOptions {
|
||||
applyInteropRequireDefault: boolean;
|
||||
}
|
||||
type StringMap = Map<string, string>;
|
||||
interface TransformOptions<TransformerConfig = unknown> extends ReducedTransformOptions {
|
||||
/** Cached file system which is used by `jest-runtime` to improve performance. */
|
||||
cacheFS: StringMap;
|
||||
/** Jest configuration of currently running project. */
|
||||
config: Config.ProjectConfig;
|
||||
/** Stringified version of the `config` - useful in cache busting. */
|
||||
configString: string;
|
||||
/** Transformer configuration passed through `transform` option by the user. */
|
||||
transformerConfig: TransformerConfig;
|
||||
}
|
||||
interface SyncTransformer<TransformerConfig = unknown> {
|
||||
/**
|
||||
* Indicates if the transformer is capable of instrumenting the code for code coverage.
|
||||
*
|
||||
* If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented.
|
||||
* If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel.
|
||||
*/
|
||||
canInstrument?: boolean;
|
||||
getCacheKey?: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => string;
|
||||
getCacheKeyAsync?: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => Promise<string>;
|
||||
process: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => TransformedSource;
|
||||
processAsync?: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => Promise<TransformedSource>;
|
||||
}
|
||||
interface AsyncTransformer<TransformerConfig = unknown> {
|
||||
/**
|
||||
* Indicates if the transformer is capable of instrumenting the code for code coverage.
|
||||
*
|
||||
* If V8 coverage is _not_ active, and this is `true`, Jest will assume the code is instrumented.
|
||||
* If V8 coverage is _not_ active, and this is `false`. Jest will instrument the code returned by this transformer using Babel.
|
||||
*/
|
||||
canInstrument?: boolean;
|
||||
getCacheKey?: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => string;
|
||||
getCacheKeyAsync?: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => Promise<string>;
|
||||
process?: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => TransformedSource;
|
||||
processAsync: (sourceText: string, sourcePath: string, options: TransformOptions<TransformerConfig>) => Promise<TransformedSource>;
|
||||
}
|
||||
/**
|
||||
* We have both sync (`process`) and async (`processAsync`) code transformation, which both can be provided.
|
||||
* `require` will always use `process`, and `import` will use `processAsync` if it exists, otherwise fall back to `process`.
|
||||
* Meaning, if you use `import` exclusively you do not need `process`, but in most cases supplying both makes sense:
|
||||
* Jest transpiles on demand rather than ahead of time, so the sync one needs to exist.
|
||||
*
|
||||
* For more info on the sync vs async model, see https://jestjs.io/docs/code-transformation#writing-custom-transformers
|
||||
*/
|
||||
type Transformer<TransformerConfig = unknown> = SyncTransformer<TransformerConfig> | AsyncTransformer<TransformerConfig>;
|
||||
type TransformerCreator<X extends Transformer<TransformerConfig>, TransformerConfig = unknown> = (transformerConfig?: TransformerConfig) => X | Promise<X>;
|
||||
/**
|
||||
* Instead of having your custom transformer implement the Transformer interface
|
||||
* directly, you can choose to export a factory function to dynamically create
|
||||
* transformers. This is to allow having a transformer config in your jest config.
|
||||
*/
|
||||
type TransformerFactory<X extends Transformer> = {
|
||||
createTransformer: TransformerCreator<X>;
|
||||
};
|
||||
//#endregion
|
||||
//#region src/ScriptTransformer.d.ts
|
||||
declare class ScriptTransformer {
|
||||
private readonly _config;
|
||||
private readonly _cacheFS;
|
||||
private readonly _cache;
|
||||
private readonly _transformCache;
|
||||
private _transformsAreLoaded;
|
||||
constructor(_config: Config.ProjectConfig, _cacheFS: StringMap);
|
||||
private _buildCacheKeyFromFileInfo;
|
||||
private _buildTransformCacheKey;
|
||||
private _getCacheKey;
|
||||
private _getCacheKeyAsync;
|
||||
private _createCachedFilename;
|
||||
private _getFileCachePath;
|
||||
private _getFileCachePathAsync;
|
||||
private _getTransformPatternAndPath;
|
||||
private _getTransformPath;
|
||||
loadTransformers(): Promise<void>;
|
||||
private _getTransformer;
|
||||
private _instrumentFile;
|
||||
private _buildTransformResult;
|
||||
transformSource(filepath: string, content: string, options: ReducedTransformOptions): TransformResult;
|
||||
transformSourceAsync(filepath: string, content: string, options: ReducedTransformOptions): Promise<TransformResult>;
|
||||
private _transformAndBuildScriptAsync;
|
||||
private _transformAndBuildScript;
|
||||
transformAsync(filename: string, options: Options, fileSource?: string): Promise<TransformResult>;
|
||||
transform(filename: string, options: Options, fileSource?: string): TransformResult;
|
||||
transformJson(filename: string, options: Options, fileSource: string): string;
|
||||
requireAndTranspileModule<ModuleType = unknown>(moduleName: string, callback?: (module: ModuleType) => void | Promise<void>, options?: RequireAndTranspileModuleOptions): Promise<ModuleType>;
|
||||
shouldTransform(filename: string): boolean;
|
||||
}
|
||||
declare function createTranspilingRequire(config: Config.ProjectConfig): Promise<(<TModuleType = unknown>(resolverPath: string, applyInteropRequireDefault?: boolean) => Promise<TModuleType>)>;
|
||||
type TransformerType = ScriptTransformer;
|
||||
declare function createScriptTransformer(config: Config.ProjectConfig, cacheFS?: StringMap): Promise<TransformerType>;
|
||||
//#endregion
|
||||
//#region src/shouldInstrument.d.ts
|
||||
declare function shouldInstrument(filename: string, options: ShouldInstrumentOptions, config: Config.ProjectConfig, loadedFilenames?: Array<string>): boolean;
|
||||
//#endregion
|
||||
//#region src/enhanceUnexpectedTokenMessage.d.ts
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
interface ErrorWithCodeFrame extends Error {
|
||||
codeFrame?: string;
|
||||
}
|
||||
declare function handlePotentialSyntaxError(e: ErrorWithCodeFrame): ErrorWithCodeFrame;
|
||||
//#endregion
|
||||
export { AsyncTransformer, CallerTransformOptions, TransformerType as ScriptTransformer, ShouldInstrumentOptions, SyncTransformer, TransformOptions, TransformResult, Options as TransformationOptions, TransformedSource, Transformer, TransformerCreator, TransformerFactory, createScriptTransformer, createTranspilingRequire, handlePotentialSyntaxError, shouldInstrument };
|
||||
Reference in New Issue
Block a user