faastjs/dist/decls/test/fixtures/util.d.ts

Serverless batch computing made simple.

import { ExecutionContext } from "ava";
import lolex from "lolex";
import { CommonOptions, Provider } from "../../index";
import { IteratorResponseMessage, Message } from "../../src/provider";
import { keysOf } from "../../src/shared";
import { Timing } from "./functions";
export { keysOf };
export declare const measureConcurrency: (timings: Timing[]) => number;
export declare const sum: (a: number[]) => number;
export declare const avg: (a: number[]) => number;
export declare const stdev: (a: number[]) => number;
export type VClock = lolex.InstalledClock<lolex.Clock>;
export declare function withClock(fn: (clock: VClock) => Promise<void>): Promise<void>;
export declare function checkResourcesCleanedUp<T extends object>(t: ExecutionContext, resources: Partial<T>): void;
export interface RecordedCall<A extends any[], R> {
    args: A;
    rv: R;
}
export interface RecordedFunction<A extends any[], R> {
    (...args: A): R;
    recordings: Array<RecordedCall<A, R>>;
}
export declare function record<A extends any[], R>(fn: (...args: A) => R): RecordedFunction<A, R>;
export declare const configs: CommonOptions[];
export declare const noValidateConfigs: {
    validateSerialization: boolean;
    childProcess?: boolean | undefined;
    childProcessMemoryMb?: number | undefined;
    concurrency?: number | undefined;
    description?: string | undefined;
    exclude?: string[] | undefined;
    rate?: number | undefined;
    env?: {
        [key: string]: string;
    } | undefined;
    gc?: "auto" | "force" | "off" | undefined;
    include?: (string | import("../../index").IncludeOption)[] | undefined;
    maxRetries?: number | undefined;
    memorySize?: number | undefined;
    mode?: "auto" | "https" | "queue" | undefined;
    packageJson?: string | object | undefined;
    useDependencyCaching?: boolean | undefined;
    retentionInDays?: number | undefined;
    speculativeRetryThreshold?: number | undefined;
    timeout?: number | undefined;
    webpackOptions?: import("webpack").Configuration | undefined;
    debugOptions?: {
        [key: string]: boolean;
    } | undefined;
}[];
export declare function title(provider: Provider, msg: string, options?: object): string;
export declare function sleep(ms: number): Promise<unknown>;
export declare function toArray<T>(gen: AsyncIterable<T> | Iterable<T>): Promise<Awaited<T>[]>;
export declare function expectMessage<T>(t: ExecutionContext, msg: Message, kind: "promise" | "iterator", expected: T): void;
export declare function checkIteratorMessages(t: ExecutionContext, rawMessages: IteratorResponseMessage[], arg: string[]): void;