@khanacademy/wonder-blocks-testing 10.1.1 → 11.0.1

package/src/respond-with.ts

@@ -1,263 +0,0 @@
-import {SettleSignal} from "./settle-signal";
-import {ResponseImpl} from "./response-impl";
-import type {GraphQLJson} from "./types";
-
-/**
- * This symbol is used so we can create an opaque type, using a custom field
- * that cannot be directly referenced since folks won't have access to the
- * symbol.
- *
- * See https://stackoverflow.com/a/56749647/23234
- */
-declare const opaque: unique symbol;
-
-// We want the parameterization here so that folks can assert a response is
-// of a specific type if passing between various functions. For example,
-// the graphql mocking framework might want to assert a response is returning
-// the expected data structure. We could use `opaque` but that would then
-// hide the `toPromise` call we want to provide.
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/**
- * Describes a mock response to a fetch request.
- */
-export type MockResponse<TData> = {
-    /**
-     * This is used to enforce the use of the TData type parameter. We won't
-     * actually attach anything to this field. Doing this makes sure that
-     * TData is relevant to the response. Without it, it will get ignored
-     * and a value of type MockResponse<string> will be considered the same
-     * type as a value of type MockResponse<number> (or any other type
-     * constraint).
-     */
-    [opaque]: TData;
-
-    /**
-     * Create a promise from the mocked response.
-     *
-     * If a signal was provided when the mock response was created, the promise
-     * will only settle to resolution or rejection if the signal is raised.
-     */
-    readonly toPromise: () => Promise<Response>;
-};
-/* eslint-enable @typescript-eslint/no-unused-vars */
-
-type InternalMockResponse =
-    | {
-          readonly type: "text";
-          readonly text: string | (() => string);
-          readonly statusCode: number;
-          readonly signal: SettleSignal | null | undefined;
-      }
-    | {
-          readonly type: "reject";
-          readonly error: Error | (() => Error);
-          readonly signal: SettleSignal | null | undefined;
-      };
-
-/**
- * Helper for creating a text-based mock response.
- */
-const textResponse = <TData>(
-    text: string | (() => string),
-    statusCode: number,
-    signal?: SettleSignal | null,
-): MockResponse<TData> =>
-    ({
-        toPromise: () =>
-            makeMockResponse({
-                type: "text",
-                text,
-                statusCode,
-                signal,
-            }),
-    } as MockResponse<TData>);
-
-/**
- * Helper for creating a rejected mock response.
- */
-const rejectResponse = (
-    error: Error | (() => Error),
-    signal?: SettleSignal | null,
-): MockResponse<never> =>
-    ({
-        toPromise: () =>
-            makeMockResponse({
-                type: "reject",
-                error,
-                signal,
-            }),
-    } as MockResponse<never>);
-
-/**
- * Helpers to define mock responses for mocked requests.
- */
-export const RespondWith = Object.freeze({
-    /**
-     * Response with text body and status code.
-     * Status code defaults to 200.
-     */
-    text: <TData = string>(
-        text: string,
-        statusCode = 200,
-        signal: SettleSignal | null = null,
-    ): MockResponse<TData> => textResponse<TData>(text, statusCode, signal),
-
-    /**
-     * Response with JSON body and status code 200.
-     */
-    json: <TJson extends Record<any, any>>(
-        json: TJson,
-        signal: SettleSignal | null = null,
-    ): MockResponse<TJson> =>
-        textResponse<TJson>(() => JSON.stringify(json), 200, signal),
-
-    /**
-     * Response with GraphQL data JSON body and status code 200.
-     */
-    graphQLData: <TData extends Record<any, any>>(
-        data: TData,
-        signal: SettleSignal | null = null,
-    ): MockResponse<GraphQLJson<TData>> =>
-        textResponse<GraphQLJson<TData>>(
-            () => JSON.stringify({data}),
-            200,
-            signal,
-        ),
-
-    /**
-     * Response with body that will not parse as JSON and status code 200.
-     */
-    unparseableBody: (signal: SettleSignal | null = null): MockResponse<any> =>
-        textResponse("INVALID JSON", 200, signal),
-
-    /**
-     * Rejects with an AbortError to simulate an aborted request.
-     */
-    abortedRequest: (signal: SettleSignal | null = null): MockResponse<any> =>
-        rejectResponse(() => {
-            const abortError = new Error("Mock request aborted");
-            abortError.name = "AbortError";
-            return abortError;
-        }, signal),
-
-    /**
-     * Rejects with the given error.
-     */
-    reject: (
-        error: Error,
-        signal: SettleSignal | null = null,
-    ): MockResponse<any> => rejectResponse(error, signal),
-
-    /**
-     * A non-200 status code with empty text body.
-     * Equivalent to calling `ResponseWith.text("", statusCode)`.
-     */
-    errorStatusCode: (
-        statusCode: number,
-        signal: SettleSignal | null = null,
-    ): MockResponse<any> => {
-        if (statusCode < 300) {
-            throw new Error(`${statusCode} is not a valid error status code`);
-        }
-        return textResponse("{}", statusCode, signal);
-    },
-
-    /**
-     * Response body that is valid JSON but not a valid GraphQL response.
-     */
-    nonGraphQLBody: (signal: SettleSignal | null = null): MockResponse<any> =>
-        textResponse(
-            () =>
-                JSON.stringify({
-                    valid: "json",
-                    that: "is not a valid graphql response",
-                }),
-            200,
-            signal,
-        ),
-
-    /**
-     * Response that is a GraphQL errors response with status code 200.
-     */
-    graphQLErrors: (
-        errorMessages: ReadonlyArray<string>,
-        signal: SettleSignal | null = null,
-    ): MockResponse<GraphQLJson<any>> =>
-        textResponse<GraphQLJson<any>>(
-            () =>
-                JSON.stringify({
-                    errors: errorMessages.map((e) => ({
-                        message: e,
-                    })),
-                }),
-            200,
-            signal,
-        ),
-});
-
-const callOnSettled = (
-    signal: SettleSignal | null | undefined,
-    fn: () => void,
-): void => {
-    if (signal == null || signal.settled) {
-        fn();
-        return;
-    }
-
-    const onSettled = () => {
-        signal.removeEventListener("settled", onSettled);
-        fn();
-    };
-    signal.addEventListener("settled", onSettled);
-};
-
-/**
- * Turns a MockResponse value to an actual Response that represents the mock.
- */
-const makeMockResponse = (
-    response: InternalMockResponse,
-): Promise<Response> => {
-    const {signal} = response;
-
-    switch (response.type) {
-        case "text":
-            return new Promise((resolve, reject: (error?: any) => void) => {
-                callOnSettled(signal, () => {
-                    const text =
-                        typeof response.text === "function"
-                            ? response.text()
-                            : response.text;
-                    resolve(
-                        new ResponseImpl(text, {status: response.statusCode}),
-                    );
-                });
-            });
-
-        case "reject":
-            return new Promise((resolve, reject: (error?: any) => void) => {
-                callOnSettled(signal, () =>
-                    reject(
-                        response.error instanceof Error
-                            ? response.error
-                            : response.error(),
-                    ),
-                );
-            });
-
-        /* istanbul ignore next */
-        default:
-            if (process.env.NODE_ENV !== "production") {
-                // If we're not in production, give an immediate signal that the
-                // dev forgot to support this new type.
-                // @ts-expect-error TS knows we can't get here and so sees
-                // `response` as `never`.
-                throw new Error(`Unknown response type: ${response.type}`);
-            }
-            // Production; assume a rejection.
-            return makeMockResponse({
-                type: "reject",
-                error: new Error("Unknown response type"),
-                signal,
-            });
-    }
-};

package/src/response-impl.ts

@@ -1,8 +0,0 @@
-// We need a version of Response. When we're in Jest JSDOM environment or a
-// version of Node that supports the fetch API (17 and up, possibly with
-// --experimental-fetch flag), then we're good, but otherwise we need an
-// implementation, so this uses node-fetch as a peer dependency and uses that
-// to provide the implementation if we don't already have one.
-export const ResponseImpl: typeof Response =
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    typeof Response === "undefined" ? require("node-fetch").Response : Response;

package/src/settle-controller.ts

@@ -1,34 +0,0 @@
-import {SettleSignal} from "./settle-signal";
-
-/**
- * A controller for the `RespondWith` API to control response settlement.
- */
-export class SettleController {
-    private _settleFn: undefined | (() => void);
-    private _signal: SettleSignal;
-
-    constructor() {
-        // Create our signal.
-        // We pass in a method to capture it's settle function so that
-        // only we can call it.
-        this._signal = new SettleSignal(
-            (settleFn: () => void) => (this._settleFn = settleFn),
-        );
-    }
-
-    /**
-     * The signal to pass to the `RespondWith` API.
-     */
-    get signal(): SettleSignal {
-        return this._signal;
-    }
-
-    /**
-     * Settle the signal and therefore any associated responses.
-     *
-     * @throws {Error} if the signal has already been settled.
-     */
-    settle(): void {
-        this._settleFn?.();
-    }
-}

package/src/settle-signal.ts

@@ -1,42 +0,0 @@
-/**
- * A signal for controlling the `RespondWith` API responses.
- *
- * This provide finely-grained control over the promise lifecycle to support
- * complex test scenarios.
- */
-export class SettleSignal extends EventTarget {
-    private _settled = false;
-
-    constructor(
-        setSettleFn: ((settleFn: () => void) => unknown) | null = null,
-    ) {
-        super();
-
-        // If we were given a function, we call it with a method that will
-        // settle ourselves. This allows the appropriate SettleController
-        // to be in charge of settling this instance.
-        setSettleFn?.(() => {
-            if (this._settled) {
-                throw new Error("SettleSignal already settled");
-            }
-            this._settled = true;
-            this.dispatchEvent(new Event("settled"));
-        });
-    }
-
-    /**
-     * An already settled signal.
-     */
-    static settle(): SettleSignal {
-        const signal = new SettleSignal();
-        signal._settled = true;
-        return signal;
-    }
-
-    /**
-     * Has this signal been settled yet?
-     */
-    get settled(): boolean {
-        return this._settled;
-    }
-}

package/src/types.ts

@@ -1,40 +0,0 @@
-import type {MockResponse} from "./respond-with";
-
-/**
- * A valid GraphQL response as supported by our mocking framework.
- * Note that we don't currently support both data and errors being set.
- */
-export type GraphQLJson<TData extends Record<any, any>> =
-    | {
-          data: TData;
-      }
-    | {
-          errors: Array<{
-              message: string;
-          }>;
-      };
-
-export type MockFn<TOperationType> = {
-    (...args: Array<any>): Promise<Response>;
-    mockOperation: MockOperationFn<TOperationType>;
-    mockOperationOnce: MockOperationFn<TOperationType>;
-};
-
-export type OperationMock<TOperation> = {
-    operation: TOperation;
-    onceOnly: boolean;
-    used: boolean;
-    response: () => Promise<Response>;
-};
-
-export type OperationMatcher<TOperation> = (
-    operation: TOperation,
-    ...args: Array<any>
-) => boolean;
-
-export type MockOperationFn<TOperationType> = <
-    TOperation extends TOperationType,
->(
-    operation: TOperation,
-    response: MockResponse<any>,
-) => MockFn<TOperationType>;