jest-worker
- Version 29.7.0
- Published
- 90.8 kB
- 4 dependencies
- MIT license
Install
npm i jest-worker
yarn add jest-worker
pnpm add jest-worker
Overview
Module for executing heavy tasks under forked processes in parallel, by providing a `Promise` based interface, minimum overhead, and bound workers.
Index
Variables
Functions
Classes
Interfaces
Type Aliases
Variables
variable CHILD_MESSAGE_CALL
const CHILD_MESSAGE_CALL: number;
variable CHILD_MESSAGE_CALL_SETUP
const CHILD_MESSAGE_CALL_SETUP: number;
variable CHILD_MESSAGE_END
const CHILD_MESSAGE_END: number;
variable CHILD_MESSAGE_INITIALIZE
const CHILD_MESSAGE_INITIALIZE: number;
variable CHILD_MESSAGE_MEM_USAGE
const CHILD_MESSAGE_MEM_USAGE: number;
Functions
function messageParent
messageParent: (message: unknown, parentProcess?: NodeJS.Process) => void;
Classes
class FifoQueue
class FifoQueue implements TaskQueue {}
First-in, First-out task queue that manages a dedicated pool for each worker as well as a shared queue. The FIFO ordering is guaranteed across the worker specific and shared queue.
class PriorityQueue
class PriorityQueue implements TaskQueue {}
Priority queue that processes tasks in natural ordering (lower priority first) according to the priority computed by the function passed in the constructor.
FIFO ordering isn't guaranteed for tasks with the same priority.
Worker specific tasks with the same priority as a non-worker specific task are always processed first.
constructor
constructor(_computePriority: ComputeTaskPriorityCallback);
method dequeue
dequeue: (workerId: number) => QueueChildMessage | null;
method enqueue
enqueue: (task: QueueChildMessage, workerId?: number) => void;
class Worker
class Worker_2 {}
The Jest farm (publicly called "Worker") is a class that allows you to queue methods across multiple child processes, in order to parallelize work. This is done by providing an absolute path to a module that will be loaded on each of the child processes, and bridged to the main process.
Bridged methods are specified by using the "exposedMethods" property of the "options" object. This is an array of strings, where each of them corresponds to the exported name in the loaded module.
You can also control the amount of workers by using the "numWorkers" property of the "options" object, and the settings passed to fork the process through the "forkOptions" property. The amount of workers defaults to the amount of CPUS minus one.
Queueing calls can be done in two ways: - Standard method: calls will be redirected to the first available worker, so they will get executed as soon as they can.
- Sticky method: if a "computeWorkerKey" method is provided within the config, the resulting string of this method will be used as a key. Every time this key is returned, it is guaranteed that your job will be processed by the same worker. This is specially useful if your workers are caching results.
constructor
constructor(workerPath: string | URL, options?: WorkerFarmOptions);
method end
end: () => Promise<PoolExitResult>;
method getStderr
getStderr: () => NodeJS.ReadableStream;
method getStdout
getStdout: () => NodeJS.ReadableStream;
method start
start: () => Promise<void>;
Interfaces
interface PromiseWithCustomMessage
interface PromiseWithCustomMessage<T> extends Promise<T> {}
property UNSTABLE_onCustomMessage
UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void;
interface TaskQueue
interface TaskQueue {}
method dequeue
dequeue: (workerId: number) => QueueChildMessage | null;
Dequeues the next item from the queue for the specified worker
Parameter workerId
the id of the worker for which the next task should be retrieved
method enqueue
enqueue: (task: QueueChildMessage, workerId?: number) => void;
Enqueues the task in the queue for the specified worker or adds it to the queue shared by all workers
Parameter task
the task to queue
Parameter workerId
the id of the worker that should process this task or undefined if there's no preference.
interface WorkerPoolInterface
interface WorkerPoolInterface {}
property send
send: WorkerCallback;
method createWorker
createWorker: (options: WorkerOptions_2) => WorkerInterface;
method end
end: () => Promise<PoolExitResult>;
method getStderr
getStderr: () => NodeJS.ReadableStream;
method getStdout
getStdout: () => NodeJS.ReadableStream;
method getWorkers
getWorkers: () => Array<WorkerInterface>;
method start
start: () => Promise<void>;
Type Aliases
type JestWorkerFarm
type JestWorkerFarm<T extends Record<string, unknown>> = Worker_2 & WorkerModule<T>;
type WorkerFarmOptions
type WorkerFarmOptions = { computeWorkerKey?: (method: string, ...args: Array<unknown>) => string | null; enableWorkerThreads?: boolean; exposedMethods?: ReadonlyArray<string>; forkOptions?: ForkOptions; maxRetries?: number; numWorkers?: number; resourceLimits?: ResourceLimits; setupArgs?: Array<unknown>; taskQueue?: TaskQueue; WorkerPool?: new ( workerPath: string, options?: WorkerPoolOptions ) => WorkerPoolInterface; workerSchedulingPolicy?: WorkerSchedulingPolicy; idleMemoryLimit?: number;};
type WorkerPoolOptions
type WorkerPoolOptions = { setupArgs: Array<unknown>; forkOptions: ForkOptions; resourceLimits: ResourceLimits; maxRetries: number; numWorkers: number; enableWorkerThreads: boolean; idleMemoryLimit?: number;};
Package Files (1)
Dependencies (4)
Dev Dependencies (8)
Peer Dependencies (0)
No peer dependencies.
Badge
To add a badge like this oneto your package's README, use the codes available below.
You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/jest-worker
.
- Markdown[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/jest-worker)
- HTML<a href="https://www.jsdocs.io/package/jest-worker"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>
- Updated .
Package analyzed in 3631 ms. - Missing or incorrect documentation? Open an issue for this package.