import { IConstruct } from "constructs"; import { Component } from "../component"; import { NodeProject } from "../javascript"; import { JsonFile } from "../json"; import { Project } from "../project"; export interface JestConfigOptions { /** * This option tells Jest that all imported modules in your tests should be mocked automatically. * All modules used in your tests will have a replacement implementation, keeping the API surface * @default - false */ readonly automock?: boolean; /** * By default, Jest runs all tests and produces all errors into the console upon completion. * The bail config option can be used here to have Jest stop running tests after n failures. * Setting bail to true is the same as setting bail to 1. * @default - 0 */ readonly bail?: boolean | number; /** * The directory where Jest should store its cached dependency information * @default - "/tmp/" */ readonly cacheDirectory?: string; /** * Automatically clear mock calls and instances before every test. * Equivalent to calling jest.clearAllMocks() before each test. * This does not remove any mock implementation that may have been provided * @default true */ readonly clearMocks?: boolean; /** * Indicates whether the coverage information should be collected while executing the test. * Because this retrofits all executed files with coverage collection statements, * it may significantly slow down your tests * @default true */ readonly collectCoverage?: boolean; /** * An array of glob patterns indicating a set of files for which coverage information should be collected. * @default - undefined */ readonly collectCoverageFrom?: string[]; /** * The directory where Jest should output its coverage files. * @default "coverage" */ readonly coverageDirectory?: string; /** * An array of regexp pattern strings that are matched against all file paths before executing the test. * If the file path matches any of the patterns, coverage information will be skipped * @default "/node_modules/" */ readonly coveragePathIgnorePatterns?: string[]; /** * Indicates which provider should be used to instrument code for coverage. * Allowed values are v8 (default) or babel * @default - "v8" */ readonly coverageProvider?: "babel" | "v8"; /** * A list of reporter names that Jest uses when writing coverage reports. Any istanbul reporter can be used * @default - ["json", "lcov", "text", "clover", "cobertura"] */ readonly coverageReporters?: string[]; /** * Specify the global coverage thresholds. This will be used to configure minimum threshold enforcement * for coverage results. Thresholds can be specified as global, as a glob, and as a directory or file path. * If thresholds aren't met, jest will fail. * @default - undefined */ readonly coverageThreshold?: CoverageThreshold; /** * This option allows the use of a custom dependency extractor. * It must be a node module that exports an object with an extract function * @default - undefined */ readonly dependencyExtractor?: string; /** * Allows for a label to be printed alongside a test while it is running. * @default - undefined */ readonly displayName?: string | any; /** * Make calling deprecated APIs throw helpful error messages. Useful for easing the upgrade process. * @default - false */ readonly errorOnDeprecated?: boolean; /** * Test files run inside a vm, which slows calls to global context properties (e.g. Math). * With this option you can specify extra properties to be defined inside the vm for faster lookups. * @default - undefined */ readonly extraGlobals?: string[]; /** * Test files are normally ignored from collecting code coverage. * With this option, you can overwrite this behavior and include otherwise ignored files in code coverage. * @default - [''] */ readonly forceCoverageMatch?: string[]; /** * A set of global variables that need to be available in all test environments. * @default - {} */ readonly globals?: any; /** * This option allows the use of a custom global setup module which exports an async function that is * triggered once before all test suites. This function gets Jest's globalConfig object as a parameter. * @default - undefined */ readonly globalSetup?: string; /** * This option allows the use of a custom global teardown module which exports an async function that is * triggered once after all test suites. This function gets Jest's globalConfig object as a parameter. * @default - undefined */ readonly globalTeardown?: string; /** * This will be used to configure the behavior of jest-haste-map, Jest's internal file crawler/cache system. * @default - {} */ readonly haste?: HasteConfig; /** * Insert Jest's globals (expect, test, describe, beforeEach etc.) into the global environment. * If you set this to false, you should import from @jest/globals * @default - true */ readonly injectGlobals?: boolean; /** * A number limiting the number of tests that are allowed to run at the same time when using test.concurrent. * Any test above this limit will be queued and executed once a slot is released. * @default - 5 */ readonly maxConcurrency?: number; /** * Specifies the maximum number of workers the worker-pool will spawn for running tests. In single run mode, * this defaults to the number of the cores available on your machine minus one for the main thread * In watch mode, this defaults to half of the available cores on your machine. * For environments with variable CPUs available, you can use percentage based configuration: "maxWorkers": "50%" * @default - the number of the cores available on your machine minus one for the main thread */ readonly maxWorkers?: number | string; /** * An array of directory names to be searched recursively up from the requiring module's location. * Setting this option will override the default, if you wish to still search node_modules for packages * include it along with any other options: ["node_modules", "bower_components"] * @default - ["node_modules"] */ readonly moduleDirectories?: string[]; /** * An array of file extensions your modules use. If you require modules without specifying a file extension, * these are the extensions Jest will look for, in left-to-right order. * @default - ["js", "json", "jsx", "ts", "tsx", "node"] */ readonly moduleFileExtensions?: string[]; /** * A map from regular expressions to module names or to arrays of module names that allow to stub out * resources, like images or styles with a single module. * @default - null */ readonly moduleNameMapper?: { [key: string]: string | string[]; }; /** * An array of regexp pattern strings that are matched against all module paths before those paths are * to be considered 'visible' to the module loader. If a given module's path matches any of the patterns, * it will not be require()-able in the test environment. * @default - [] */ readonly modulePathIgnorePatterns?: string[]; /** * An alternative API to setting the NODE_PATH env variable, modulePaths is an array of absolute paths * to additional locations to search when resolving modules. Use the string token to include * the path to your project's root directory. Example: ["/app/"]. * @default - [] */ readonly modulePaths?: string[]; /** * Activates notifications for test results. * @default - false */ readonly notify?: boolean; /** * Specifies notification mode. Requires notify: true * @default - failure-change */ readonly notifyMode?: "always" | "failure" | "success" | "change" | "success-change" | "failure-change"; /** * A preset that is used as a base for Jest's configuration. A preset should point to an npm module * that has a jest-preset.json or jest-preset.js file at the root. * @default - undefined */ readonly preset?: string; /** * Sets the path to the prettier node module used to update inline snapshots. * @default - "prettier" */ readonly prettierPath?: string; /** * When the projects configuration is provided with an array of paths or glob patterns, Jest will * run tests in all of the specified projects at the same time. This is great for monorepos or * when working on multiple projects at the same time. * @default - undefined */ readonly projects?: Array; /** * Use this configuration option to add custom reporters to Jest. A custom reporter is a class * that implements onRunStart, onTestStart, onTestResult, onRunComplete methods that will be * called when any of those events occurs. * @default - undefined */ readonly reporters?: JestReporter[]; /** * Automatically reset mock state before every test. Equivalent to calling jest.resetAllMocks() * before each test. This will lead to any mocks having their fake implementations removed but * does not restore their initial implementation. * @default - false */ readonly resetMocks?: boolean; /** * By default, each test file gets its own independent module registry. Enabling resetModules * goes a step further and resets the module registry before running each individual test. * @default - false */ readonly resetModules?: boolean; /** * This option allows the use of a custom resolver. * https://jestjs.io/docs/en/configuration#resolver-string * @default - undefined */ readonly resolver?: string; /** * Automatically restore mock state before every test. Equivalent to calling jest.restoreAllMocks() * before each test. This will lead to any mocks having their fake implementations removed and * restores their initial implementation. * @default - false */ readonly restoreMocks?: boolean; /** * The root directory that Jest should scan for tests and modules within. If you put your Jest * config inside your package.json and want the root directory to be the root of your repo, the * value for this config param will default to the directory of the package.json. * @default - directory of the package.json */ readonly rootDir?: string; /** * A list of paths to directories that Jest should use to search for files in. * @default - [""] */ readonly roots?: string[]; /** * This option allows you to use a custom runner instead of Jest's default test runner. * @default - "jest-runner" */ readonly runner?: string; /** * A list of paths to modules that run some code to configure or set up the testing environment. * Each setupFile will be run once per test file. Since every test runs in its own environment, * these scripts will be executed in the testing environment immediately before executing the * test code itself. * @default - [] */ readonly setupFiles?: string[]; /** * A list of paths to modules that run some code to configure or set up the testing framework * before each test file in the suite is executed. Since setupFiles executes before the test * framework is installed in the environment, this script file presents you the opportunity of * running some code immediately after the test framework has been installed in the environment. * @default - [] */ readonly setupFilesAfterEnv?: string[]; /** * The number of seconds after which a test is considered as slow and reported as such in the results. * @default - 5 */ readonly slowTestThreshold?: number; /** * The path to a module that can resolve test<->snapshot path. This config option lets you customize * where Jest stores snapshot files on disk. * @default - undefined */ readonly snapshotResolver?: string; /** * A list of paths to snapshot serializer modules Jest should use for snapshot testing. * @default = [] */ readonly snapshotSerializers?: string[]; /** * The test environment that will be used for testing. The default environment in Jest is a * browser-like environment through jsdom. If you are building a node service, you can use the node * option to use a node-like environment instead. * @default - "jsdom" */ readonly testEnvironment?: string; /** * Test environment options that will be passed to the testEnvironment. * The relevant options depend on the environment. * @default - {} */ readonly testEnvironmentOptions?: any; /** * The exit code Jest returns on test failure. * @default - 1 */ readonly testFailureExitCode?: number; /** * The glob patterns Jest uses to detect test files. By default it looks for .js, .jsx, .ts and .tsx * files inside of __tests__ folders, as well as any files with a suffix of .test or .spec * (e.g. Component.test.js or Component.spec.js). It will also find files called test.js or spec.js. * @default ['**\/__tests__/**\/*.[jt]s?(x)', '**\/*(*.)@(spec|test).[tj]s?(x)'] */ readonly testMatch?: string[]; /** * An array of regexp pattern strings that are matched against all test paths before executing the test. * If the test path matches any of the patterns, it will be skipped. * @default - ["/node_modules/"] */ readonly testPathIgnorePatterns?: string[]; /** * The pattern or patterns Jest uses to detect test files. By default it looks for .js, .jsx, .ts and .tsx * files inside of __tests__ folders, as well as any files with a suffix of .test or .spec * (e.g. Component.test.js or Component.spec.js). It will also find files called test.js or spec.js. * @default - (/__tests__/.*|(\\.|/)(test|spec))\\.[jt]sx?$ */ readonly testRegex?: string | string[]; /** * This option allows the use of a custom results processor. * @default - undefined */ readonly testResultsProcessor?: string; /** * This option allows the use of a custom test runner. The default is jasmine2. A custom test runner * can be provided by specifying a path to a test runner implementation. * @default - "jasmine2" */ readonly testRunner?: string; /** * This option allows you to use a custom sequencer instead of Jest's default. * Sort may optionally return a Promise. * @default - "@jest/test-sequencer" */ readonly testSequencer?: string; /** * Default timeout of a test in milliseconds. * @default - 5000 */ readonly testTimeout?: number; /** * This option sets the URL for the jsdom environment. It is reflected in properties such as location.href. * @default - "http://localhost" */ readonly testURL?: string; /** * Setting this value to legacy or fake allows the use of fake timers for functions such as setTimeout. * Fake timers are useful when a piece of code sets a long timeout that we don't want to wait for in a test. * @default - "real" */ readonly timers?: string; /** * A map from regular expressions to paths to transformers. A transformer is a module that provides a * synchronous function for transforming source files. * @default - {"\\.[jt]sx?$": "babel-jest"} */ readonly transform?: { [key: string]: Transform; }; /** * An array of regexp pattern strings that are matched against all source file paths before transformation. * If the test path matches any of the patterns, it will not be transformed. * @default - ["/node_modules/", "\\.pnp\\.[^\\\/]+$"] */ readonly transformIgnorePatterns?: string[]; /** * An array of regexp pattern strings that are matched against all modules before the module loader will * automatically return a mock for them. If a module's path matches any of the patterns in this list, it * will not be automatically mocked by the module loader. * @default - [] */ readonly unmockedModulePathPatterns?: string[]; /** * Indicates whether each individual test should be reported during the run. All errors will also * still be shown on the bottom after execution. Note that if there is only one test file being run * it will default to true. * @default - false */ readonly verbose?: boolean; /** * An array of RegExp patterns that are matched against all source file paths before re-running tests * in watch mode. If the file path matches any of the patterns, when it is updated, it will not trigger * a re-run of tests. * @default - [] */ readonly watchPathIgnorePatterns?: string[]; /** * * @default - */ readonly watchPlugins?: WatchPlugin[]; /** * Whether to use watchman for file crawling. * @default - true */ readonly watchman?: boolean; /** * Escape hatch to allow any value */ readonly additionalOptions?: { [name: string]: any; }; /** * Escape hatch to allow any value (JS/TS only) * * @deprecated use `additionalOptions` instead. * * @jsii ignore */ readonly [name: string]: any; } /** * Options for discoverTestMatchPatternsForDirs. */ export interface JestDiscoverTestMatchPatternsForDirsOptions { /** The file extension pattern to use. Defaults to "[jt]s?(x)". */ readonly fileExtensionPattern?: string; } export declare class Transform { private readonly name; private readonly options?; constructor(name: string, options?: any | undefined); /** * @jsii ignore * @internal */ toJSON(): string | any[]; } export declare class WatchPlugin { private readonly name; private readonly options?; constructor(name: string, options?: any | undefined); /** * @jsii ignore * @internal */ toJSON(): string | any[]; } export interface JestOptions { /** * Collect coverage. Deprecated * @default true * @deprecated use jestConfig.collectCoverage */ readonly coverage?: boolean; /** * Include the `text` coverage reporter, which means that coverage summary is printed * at the end of the jest execution. * * @default true */ readonly coverageText?: boolean; /** * Defines `testPathIgnorePatterns` and `coveragePathIgnorePatterns` * @default ["/node_modules/"] * @deprecated use jestConfig.coveragePathIgnorePatterns or jestConfig.testPathIgnorePatterns respectively */ readonly ignorePatterns?: string[]; /** * Result processing with jest-junit. * * Output directory is `test-reports/`. * * @default true */ readonly junitReporting?: boolean; /** * Preserve the default Jest reporter when additional reporters are added. * * @default true */ readonly preserveDefaultReporters?: boolean; /** * Whether to update snapshots in task "test" (which is executed in task "build" and build workflows), * or create a separate task "test:update" for updating snapshots. * * @default - ALWAYS */ readonly updateSnapshot?: UpdateSnapshot; /** * The version of jest to use. * * Note that same version is used as version of `@types/jest` and `ts-jest` (if Typescript in use), so given version should work also for those. * * With Jest 30 ts-jest version 29 is used (if Typescript in use) * * @default - installs the latest jest version */ readonly jestVersion?: string; /** * Path to JSON config file for Jest * * @default - No separate config file, jest settings are stored in package.json */ readonly configFilePath?: string; /** * Jest configuration. * @default - default jest configuration */ readonly jestConfig?: JestConfigOptions; /** * Additional options to pass to the Jest CLI invocation * @default - no extra options */ readonly extraCliOptions?: string[]; /** * Pass with no tests * @default - true */ readonly passWithNoTests?: boolean; } export interface CoverageThreshold { readonly branches?: number; readonly functions?: number; readonly lines?: number; readonly statements?: number; } export declare enum UpdateSnapshot { /** * Always update snapshots in "test" task. */ ALWAYS = "always", /** * Never update snapshots in "test" task and create a separate "test:update" task. */ NEVER = "never" } export interface HasteConfig { readonly computeSha1?: boolean; readonly defaultPlatform?: string | undefined; readonly hasteImplModulePath?: string; readonly platforms?: Array; readonly throwOnModuleCollision?: boolean; } export declare class JestReporter { private readonly name; private readonly options?; constructor(name: string, options?: { [key: string]: any; } | undefined); /** * @jsii ignore * @internal */ toJSON(): any; } /** * Installs the following npm scripts: * * - `test`, intended for testing locally and in CI. Will update snapshots unless `updateSnapshot: UpdateSnapshot: NEVER` is set. * - `test:watch`, intended for automatically rerunning tests when files change. * - `test:update`, intended for testing locally and updating snapshots to match the latest unit under test. Only available when `updateSnapshot: UpdateSnapshot: NEVER`. * */ export declare class Jest extends Component { /** * Returns the singleton Jest component of a project or undefined if there is none. */ static of(project: Project): Jest | undefined; readonly project: NodeProject; /** * Escape hatch. */ readonly config: any; /** * Jest version, including `@` symbol, like `@^29` */ readonly jestVersion: string; /** * Jest config file. `undefined` if settings are written to `package.json` */ readonly file?: JsonFile; private readonly testMatch; private readonly ignorePatterns; private readonly watchIgnorePatterns; private readonly coverageReporters; private readonly reporters; private readonly jestConfig?; private readonly extraCliOptions; private readonly passWithNoTests; private _snapshotResolver; constructor(scope: IConstruct, options?: JestOptions); /** * Adds a test match pattern. * @param pattern glob pattern to match for tests */ addTestMatch(pattern: string): void; /** * Build standard test match patterns for a directory. * @param dirs The directories to add test matches for. Matches any folder if not specified or an empty array. * @param options Options for building test match patterns. */ discoverTestMatchPatternsForDirs(dirs: string[], options?: JestDiscoverTestMatchPatternsForDirsOptions): void; /** * Build standard test match patterns for a directory. * @param dirs The directories to add test matches for. Matches any folder if not specified. * @param fileExtensionPattern The file extension pattern to use. Defaults to "[jt]s?(x)". * @returns The test match patterns. */ private buildTestMatchPatternsForDirs; /** * Adds a watch ignore pattern. * @param pattern The pattern (regular expression). */ addWatchIgnorePattern(pattern: string): void; addIgnorePattern(pattern: string): void; addReporter(reporter: JestReporter): void; /** * Adds a a setup file to Jest's setupFiles configuration. * @param file File path to setup file */ addSetupFile(file: string): void; /** * Adds a a setup file to Jest's setupFilesAfterEnv configuration. * @param file File path to setup file */ addSetupFileAfterEnv(file: string): void; addSnapshotResolver(file: string): void; /** * Adds one or more moduleNameMapper entries to Jest's configuration. * Will overwrite if the same key is used as a pre-existing one. * * @param moduleNameMapperAdditions - A map from regular expressions to module names or to arrays of module names that allow to stub out resources, like images or styles with a single module. */ addModuleNameMappers(moduleNameMapperAdditions: { [key: string]: string | string[]; }): void; /** * Adds one or more modulePaths to Jest's configuration. * * @param modulePaths - An array of absolute paths to additional locations to search when resolving modules * */ addModulePaths(...modulePaths: string[]): void; /** * Adds one or more roots to Jest's configuration. * * @param roots - A list of paths to directories that Jest should use to search for files in. */ addRoots(...roots: string[]): void; private configureTestCommand; }