@gfdelarue/testkit 0.3.0

package/dist/engines/k6/runtime/ambient-types/k6/index.d.ts

@@ -0,0 +1,126 @@
+/**
+ * k6 JavaScript API.
+ * https://grafana.com/docs/k6/latest/
+ *
+ * @privateRemarks
+ * Uses a branding pattern throughout to reflect the custom classes exposed by
+ * the k6 runtime. These classes have internal state not visible in JavaScript.
+ * The object passed back to k6 must be an actual instance created on the
+ * golang side. Duck typed objects are not safe.
+ *
+ * Each class includes a protected property __brand: never. The brand breaks
+ * duck typing for noninstances with an identical public shape.
+ *
+ * This follows the pattern used in the TypeScript compiler:
+ * https://github.com/Microsoft/TypeScript/blob/7b48a182c05ea4dea81bab73ecbbe9e013a79e99/src/compiler/types.ts#L693-L698
+ *
+ * @packageDocumentation
+ */
+
+import "./global.js"; // Type global environment
+
+// === Main ===
+// ------------
+
+/**
+ * Run checks on a value.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6/check/
+ * @template VT - Value type.
+ * @param val - Value to test.
+ * @param sets - Tests (checks) to run on the value.
+ * @param tags - Extra tags to attach to metrics emitted.
+ * @returns `true` if all checks have succeeded, otherwise `false`.
+ * @example
+ * check(res, {
+ *  "response code was 200": (res) => res.status == 200,
+ *  "body size was 1234 bytes": (res) => res.body.length == 1234,
+ * });
+ */
+export function check<VT>(val: VT, sets: Checkers<VT>, tags?: object): boolean;
+
+/**
+ * Immediately throw an error, aborting the current script iteration.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6/fail/
+ * @param err - Error message that gets printed to stderr.
+ * @example
+ * fail("abort current iteration");
+ */
+export function fail(err?: string): never;
+
+/**
+ * Run code inside a group.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6/group/
+ * @template RT - Return type.
+ * @param name - Name of the group.
+ * @param fn - Group body. Code to be executed in the group context.
+ * @returns The return value of `fn`.
+ * @example
+ * group("group name", function() {
+ *  ..
+ * });
+ */
+export function group<RT>(name: string, fn: () => RT): RT;
+
+/**
+ * Set seed to get a reproducible pseudo-random number using Math.random.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6/randomseed/
+ * @param int - The seed value.
+ * @example
+ * randomSeed(123456789);
+ */
+export function randomSeed(int: number): void;
+
+/**
+ * Suspend VU execution for the specified duration.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6/sleep/
+ * @param t - Duration, in seconds.
+ * @example
+ * sleep(3);
+ */
+export function sleep(t: number): void;
+
+/**
+ * Check procedure.
+ * @template VT - Value type.
+ */
+export interface Checker<VT> {
+    /**
+     * Check procedure.
+     * @param val - Value to check.
+     * @returns Whether check passed.
+     */
+    (val: VT): boolean;
+}
+
+/**
+ * Named check procedures.
+ * @template VT - Value type.
+ */
+export interface Checkers<VT> {
+    [description: string]: Checker<VT>;
+}
+
+// === Common types ===
+// --------------------
+
+// === JSON ===
+// ------------
+
+/**
+ * JavaScript value representable with JSON.
+ */
+export type JSONValue = null | boolean | number | string | JSONArray | JSONObject;
+
+/**
+ * Array representable with JSON.
+ */
+export interface JSONArray extends Array<JSONValue> {}
+
+/**
+ * Object representable with JSON.
+ */
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+
+export * as default from "k6";

package/dist/engines/k6/runtime/ambient-types/k6/metrics/index.d.ts

@@ -0,0 +1,66 @@
+/*
+ * Custom metrics.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-metrics/
+ */
+
+/**
+ * Custom metric.
+ */
+export abstract class Metric {
+    protected __brand: never;
+
+    /**
+     * @param name - Metric name.
+     * @param isTime - Whether values are time values.
+     */
+    constructor(name: string, isTime?: boolean);
+
+    /** The name of the custom metric. */
+    name: string;
+
+    /**
+     * Add value.
+     * @param value - Value to add.
+     * @param tags - Tags to attach to data point.
+     */
+    add(value: number | boolean, tags?: { [name: string]: string }): void;
+}
+
+/**
+ * Cumulative counter.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-metrics/counter/
+ *
+ * @example
+ * // Create instance on init context
+ * const myCounter = new Counter('metricName');
+ * export default function() {
+ *   myCounter.add(1);
+ * }
+ */
+export class Counter extends Metric {
+    protected __brand: never;
+}
+
+/**
+ * Gauge. Holds only latest value.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-metrics/gauge/
+ */
+export class Gauge extends Metric {
+    protected __brand: never;
+}
+
+/**
+ * Tracks percentage of nonzero values.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-metrics/rate/
+ */
+export class Rate extends Metric {
+    protected __brand: never;
+}
+
+/**
+ * Calculates summary statistics.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-metrics/trend/
+ */
+export class Trend extends Metric {
+    protected __brand: never;
+}

package/dist/engines/k6/runtime/ambient-types/k6/net/grpc/index.d.ts

@@ -0,0 +1,247 @@
+// === Response ===
+// ----------------
+
+/**
+ * gRPC response.
+ */
+export interface Response {
+    status: number;
+
+    message: object;
+
+    headers: object;
+
+    trailers: object;
+
+    error: object;
+}
+
+export interface ConnectParams {
+    /**
+     * If `true` will connect to the gRPC server using plaintext i.e. insecure.
+     */
+    plaintext?: boolean;
+
+    /**
+     * If `true` connection will try to use the gRPC server reflection protocol.
+     * https://github.com/grpc/grpc/blob/master/doc/server-reflection.md
+     */
+    reflect?: boolean;
+
+    /**
+     * Metadata to send with reflection request.
+     */
+    reflectMetadata?: object;
+
+    /**
+     * Connection timeout to use.
+     */
+    timeout?: string | number;
+
+    /**
+     *  Maximum message size in bytes the client can receive.
+     */
+    maxReceiveSize?: number;
+
+    /**
+     * Maximum message size in bytes the client can send.
+     */
+    maxSendSize?: number;
+
+    /**
+     * TLS settings of the connection.
+     */
+    tls?: TLSParams;
+}
+
+export interface TLSParams {
+    /**
+     *  PEM formatted client certificate.
+     */
+    cert: string;
+
+    /**
+     * PEM formatted client private key.
+     */
+    key: string;
+
+    /**
+     * Password for decrypting the client's private key.
+     */
+    password?: string;
+
+    /**
+     * PEM formatted string/strings of the certificate authorities.
+     */
+    cacerts?: string | string[];
+}
+
+export interface Params {
+    /**
+     * Object with key-value pairs representing custom metadata the user would like to add to the request.
+     */
+    metadata?: object;
+
+    /**
+     * Key-value pairs where the keys are names of tags and the values are tag values
+     */
+    tags?: object;
+
+    /**
+     * Request timeout to use.
+     */
+    timeout?: string | number;
+
+    /**
+     * Specify if response messages should be discarded.
+     */
+    discardResponseMessage?: boolean;
+}
+
+export interface GrpcError {
+    code: number;
+    details: string[] | object[];
+    message: string;
+}
+
+/**
+ * Health check status values as defined by the gRPC Health Checking Protocol.
+ */
+export type HealthCheckStatus = "SERVING" | "NOT_SERVING" | "UNKNOWN";
+
+/**
+ * Response from a gRPC health check.
+ */
+export interface HealthCheckResponse {
+    /**
+     * The health status of the service.
+     */
+    Status: HealthCheckStatus;
+}
+
+/**
+ * gRPC client to interact with a gRPC server.
+ * https://grafana.com/docs/k6/latest/javascript-api/k6-net-grpc/client/
+ */
+export class Client {
+    protected __brand: never;
+
+    constructor();
+
+    /** Opens a connection to a gRPC server. */
+    connect(address: string, params?: ConnectParams): void;
+
+    /** Loads and parses the protocol buffer descriptors. */
+    load(importPaths: string[], ...protoFiles: string[]): void;
+
+    /** Loads a protoset and parses the protocol buffer descriptors */
+    loadProtoset(protosetPath: string): void;
+
+    /** Invokes an unary RPC request. */
+    invoke(url: string, request: object, params?: Params): Response;
+
+    /** Asynchronously invokes an unary RPC request. */
+    asyncInvoke(url: string, request: object, params?: Params): Promise<Response>;
+
+    /** Close the connection. */
+    close(): void;
+
+    /**
+     * Performs a health check on the gRPC service.
+     * Uses the standard gRPC Health Checking Protocol.
+     *
+     * @param service - Optional service name to check. If not provided, checks overall server health.
+     * @returns The health check response
+     */
+    healthCheck(service?: string): HealthCheckResponse;
+}
+
+/**
+ * StreamEvent describes the possible events that can be emitted
+ * by a gRPC stream.
+ */
+export type StreamEvent =
+    /**
+     * Event fired when data has been received from the server.
+     */
+    | "data"
+    /**
+     * Event fired when a stream has been closed due to an error.
+     */
+    | "error"
+    /**
+     * Event fired when the stream closes.
+     */
+    | "end";
+
+/**
+ * StreamMessageMetadata handles gRPC stream messages's metadata
+ */
+export interface StreamMessageMetadata {
+    /**
+     * Contains the timestamp of the original event (for example, when a message has been received).
+     */
+    ts: number;
+}
+
+/**
+ * Stream allows you to use streaming RPCs.
+ */
+export class Stream {
+    /**
+     * The gRPC stream constructor, representing a single gRPC stream.
+     *
+     * @param client - the gRPC client to use, it must be connected.
+     * @param url - the RPC method to call.
+     * @param params - the parameters to use for the RPC call.
+     */
+    constructor(client: Client, url: string, params?: Params);
+
+    /**
+     * Set up handler functions for various events on the gRPC stream.
+     *
+     * @param event - the event to listen for
+     * @param listener - the callback to invoke when the event is emitted
+     */
+    on(
+        event: StreamEvent,
+        listener: (data: object | GrpcError | undefined, metadata: StreamMessageMetadata) => void,
+    ): void;
+
+    /**
+     * Writes a request to the stream.
+     *
+     * @param request - the request (message) to send to the server
+     */
+    write(request: object): void;
+
+    /**
+     * Signals to the server that the client has finished sending messages.
+     */
+    end(): void;
+}
+
+export const StatusOK: number;
+export const StatusCanceled: number;
+export const StatusUnknown: number;
+export const StatusInvalidArgument: number;
+export const StatusDeadlineExceeded: number;
+export const StatusNotFound: number;
+export const StatusAlreadyExists: number;
+export const StatusPermissionDenied: number;
+export const StatusResourceExhausted: number;
+export const StatusFailedPrecondition: number;
+export const StatusAborted: number;
+export const StatusOutOfRange: number;
+export const StatusUnimplemented: number;
+export const StatusInternal: number;
+export const StatusUnavailable: number;
+export const StatusDataLoss: number;
+export const StatusUnauthenticated: number;
+
+export const HealthCheckServing: HealthCheckStatus;
+export const HealthCheckNotServing: HealthCheckStatus;
+export const HealthCheckUnknown: HealthCheckStatus;
+export const HealthCheckServiceUnkown: HealthCheckStatus;
+
+export * as default from "k6/net/grpc";