@prosopo/procaptcha-pow 2.10.23 → 2.10.25

package/src/tests/managerHarness.ts

@@ -0,0 +1,135 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import type {
+	Account,
+	FrictionlessState,
+	GetPowCaptchaResponse,
+	PowCaptchaSolutionResponse,
+	ProcaptchaCallbacks,
+	ProcaptchaClientConfigInput,
+	ProcaptchaState,
+	RandomProvider,
+} from "@prosopo/types";
+import { vi } from "vitest";
+
+/**
+ * Shared fixtures for the manager suite. Kept out of the test file so the mock
+ * factories, which vitest hoists above every import, can build their canned
+ * responses from the same shapes the assertions use.
+ */
+
+export const PROVIDER_URL = "https://provider.one";
+export const OTHER_PROVIDER_URL = "https://provider.two";
+export const USER_ADDRESS = "user-address";
+export const SITE_KEY = "site-key";
+
+export const config = (
+	overrides: Partial<ProcaptchaClientConfigInput> = {},
+): ProcaptchaClientConfigInput => ({
+	account: { address: SITE_KEY },
+	defaultEnvironment: "production",
+	...overrides,
+});
+
+export const state = (
+	overrides: Partial<ProcaptchaState> = {},
+): ProcaptchaState => ({
+	isHuman: false,
+	index: 0,
+	solutions: [],
+	captchaApi: undefined,
+	challenge: undefined,
+	showModal: false,
+	loading: false,
+	account: undefined,
+	dappAccount: undefined,
+	submission: undefined,
+	timeout: undefined,
+	successfullChallengeTimeout: undefined,
+	sendData: false,
+	attemptCount: 0,
+	error: undefined,
+	sessionId: undefined,
+	...overrides,
+});
+
+export type SignRaw = NonNullable<
+	NonNullable<Account["extension"]>["signer"]["signRaw"]
+>;
+
+/**
+ * An account carrying just enough of an injected extension to sign: the rest of
+ * the interface is never touched by the manager, but the type demands it.
+ */
+export const account = (signRaw?: SignRaw): Account => ({
+	account: { address: USER_ADDRESS },
+	extension: {
+		name: "test-extension",
+		version: "0.0.0",
+		accounts: {
+			get: async () => [{ address: USER_ADDRESS }],
+			subscribe: () => () => undefined,
+		},
+		signer: signRaw ? { signRaw } : {},
+	},
+});
+
+export const accountWithoutExtension = (): Account => ({
+	account: { address: USER_ADDRESS },
+});
+
+export const randomProvider = (url: string = PROVIDER_URL): RandomProvider => ({
+	providerAccount: "provider-account",
+	provider: { url },
+});
+
+export const challengeResponse = (
+	overrides: Partial<GetPowCaptchaResponse> = {},
+): GetPowCaptchaResponse => ({
+	challenge: "0x1___0xdeadbeef___1700000000000",
+	difficulty: 2,
+	timestamp: "1700000000000",
+	signature: { provider: { challenge: "0xprovider-challenge" } },
+	status: "ok",
+	...overrides,
+});
+
+export const solutionResponse = (
+	overrides: Partial<PowCaptchaSolutionResponse> = {},
+): PowCaptchaSolutionResponse => ({
+	verified: true,
+	status: "ok",
+	...overrides,
+});
+
+export const callbacks = (
+	overrides: Partial<ProcaptchaCallbacks> = {},
+): ProcaptchaCallbacks => ({ ...overrides });
+
+/**
+ * The signer every fixture account uses, so a test can assert on what the
+ * manager asked the extension to sign without rebuilding the frictionless
+ * state it was handed.
+ */
+export const signRawMock = vi.fn<SignRaw>();
+
+export const frictionless = (
+	overrides: Partial<FrictionlessState> = {},
+): FrictionlessState => ({
+	provider: randomProvider(),
+	userAccount: account(signRawMock),
+	restart: () => undefined,
+	...overrides,
+});

package/src/tests/procaptchaPoW.unit.test.ts

@@ -0,0 +1,120 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import type { Ti18n } from "@prosopo/locale";
+import type { ProcaptchaProps } from "@prosopo/types";
+import { type ReactElement, act, createElement } from "react";
+import { type Root, createRoot } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import * as entrypoint from "../index.js";
+import { config } from "./managerHarness.js";
+
+/**
+ * The outer component exists only to lazy-load the widget and hand it the
+ * props it was given — which it once did by naming them one at a time, quietly
+ * dropping `onEscalate` and `autoStart`.
+ */
+const mocks = vi.hoisted(() => ({
+	received: [] as ProcaptchaProps[],
+}));
+
+vi.mock("../components/ProcaptchaWidget.js", async () => {
+	const { createElement } = await import("react");
+	return {
+		default: (props: ProcaptchaProps) => {
+			mocks.received.push(props);
+			return createElement("div", { "data-testid": "widget" });
+		},
+	};
+});
+
+let container: HTMLDivElement;
+let root: Root;
+
+const props = (overrides: Partial<ProcaptchaProps> = {}): ProcaptchaProps => ({
+	config: config(),
+	callbacks: {},
+	i18n: undefined as unknown as Ti18n,
+	...overrides,
+});
+
+const render = async (widgetProps: ProcaptchaProps): Promise<void> => {
+	await act(async () => {
+		root.render(
+			createElement(entrypoint.ProcaptchaPow, widgetProps) as ReactElement,
+		);
+	});
+};
+
+beforeEach(() => {
+	mocks.received.length = 0;
+	container = document.createElement("div");
+	document.body.appendChild(container);
+	act(() => {
+		root = createRoot(container);
+	});
+});
+
+afterEach(() => {
+	act(() => {
+		root.unmount();
+	});
+	container.remove();
+});
+
+describe("ProcaptchaPow", () => {
+	test("renders the widget once it has loaded", async () => {
+		await render(props());
+		expect(container.querySelector('[data-testid="widget"]')).not.toBeNull();
+	});
+
+	test("passes on the props the widget needs but never names", async () => {
+		// Enumerating props here dropped onEscalate and autoStart, so the manager
+		// closed over an undefined escalation handler and the PoW checkbox span
+		// forever after an escalated solve.
+		const onEscalate = vi.fn();
+		const onSessionInvalidated = vi.fn();
+		await render(
+			props({
+				onEscalate,
+				autoStart: true,
+				startCoords: { x: 1, y: 2 },
+				onSessionInvalidated,
+			}),
+		);
+		expect(mocks.received[0]).toMatchObject({
+			onEscalate,
+			autoStart: true,
+			startCoords: { x: 1, y: 2 },
+			onSessionInvalidated,
+		});
+	});
+
+	test("passes on the props it does name, too", async () => {
+		const callbacks = { onHuman: vi.fn<(token: string) => void>() };
+		await render(props({ callbacks }));
+		expect(mocks.received[0]?.callbacks).toBe(callbacks);
+		expect(mocks.received[0]?.config).toEqual(config());
+	});
+});
+
+describe("the package entrypoint", () => {
+	test("exports the widget a consumer mounts, and nothing else", () => {
+		// The inner ProcaptchaWidget is a default export, which `export *` does
+		// not re-export: consumers get the lazy-loading wrapper only, which is
+		// the one that works outside a bundler that can code-split.
+		expect(typeof entrypoint.ProcaptchaPow).toBe("function");
+		expect(Object.keys(entrypoint)).toEqual(["ProcaptchaPow"]);
+	});
+});

package/src/tests/procaptchaPow.test-d.ts

@@ -0,0 +1,122 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import type { Ti18n } from "@prosopo/locale";
+import type {
+	FrictionlessState,
+	ProcaptchaCallbacks,
+	ProcaptchaClientConfigInput,
+	ProcaptchaEscalationHandler,
+	ProcaptchaProps,
+	ProcaptchaState,
+	ProcaptchaStateUpdateFn,
+} from "@prosopo/types";
+import type { ReactElement } from "react";
+import { assertType, describe, expectTypeOf, test } from "vitest";
+import type * as entrypoint from "../index.js";
+import { ProcaptchaPow } from "../index.js";
+import { Manager } from "../services/Manager.js";
+import { config, frictionless, state } from "./managerHarness.js";
+
+/** The widget only ever reads `language`/`changeLanguage` off this. */
+const i18n = (): Ti18n => undefined as unknown as Ti18n;
+
+describe("the package entrypoint's types", () => {
+	test("ProcaptchaPow takes the shared widget props and renders an element", () => {
+		expectTypeOf(ProcaptchaPow).parameters.toEqualTypeOf<[ProcaptchaProps]>();
+		expectTypeOf(ProcaptchaPow).returns.toExtend<ReactElement>();
+	});
+
+	test("the inner widget's default export is not re-exported", () => {
+		// `export *` skips default exports, so consumers can only reach the lazy
+		// wrapper — the one that works without a code-splitting bundler.
+		expectTypeOf<keyof typeof entrypoint>().toEqualTypeOf<"ProcaptchaPow">();
+	});
+
+	test("config, callbacks and i18n are all required", () => {
+		// @ts-expect-error - a widget with no config has no provider to talk to.
+		assertType<ProcaptchaProps>({ callbacks: {}, i18n: i18n() });
+		// @ts-expect-error - callbacks decide what a solve reports back.
+		assertType<ProcaptchaProps>({ config: config(), i18n: i18n() });
+		assertType<ProcaptchaProps>({
+			config: config(),
+			callbacks: {},
+			i18n: i18n(),
+		});
+	});
+});
+
+describe("Manager's types", () => {
+	const updateState: ProcaptchaStateUpdateFn = () => undefined;
+	const callbacks: ProcaptchaCallbacks = {};
+
+	test("only the first four arguments are required", () => {
+		assertType<ReturnType<typeof Manager>>(
+			Manager(config(), state(), updateState, callbacks),
+		);
+		// @ts-expect-error - callbacks decide what a solve reports back.
+		Manager(config(), state(), updateState);
+	});
+
+	test("the optional arguments keep their positions", () => {
+		expectTypeOf(Manager)
+			.parameter(4)
+			.toEqualTypeOf<FrictionlessState | undefined>();
+		expectTypeOf(Manager)
+			.parameter(5)
+			.toEqualTypeOf<ProcaptchaEscalationHandler | undefined>();
+		expectTypeOf(Manager)
+			.parameter(6)
+			.toEqualTypeOf<(() => string | undefined) | undefined>();
+	});
+
+	test("it exposes exactly start and resetState", () => {
+		expectTypeOf<keyof ReturnType<typeof Manager>>().toEqualTypeOf<
+			"start" | "resetState"
+		>();
+		expectTypeOf<ReturnType<typeof Manager>["start"]>().toEqualTypeOf<
+			(x?: number, y?: number) => Promise<void>
+		>();
+		// resetState takes the frictionless restart callback the widget hands it
+		// on an invalidated session, and nothing else.
+		expectTypeOf<
+			Parameters<ReturnType<typeof Manager>["resetState"]>
+		>().toEqualTypeOf<[frictionlessRestart?: (() => void) | undefined]>();
+		expectTypeOf<
+			ReturnType<ReturnType<typeof Manager>["resetState"]>
+		>().toEqualTypeOf<void>();
+	});
+
+	test("start's coordinates are optional numbers", () => {
+		const manager: ReturnType<typeof Manager> = Manager(
+			config(),
+			state(),
+			updateState,
+			callbacks,
+			frictionless(),
+		);
+		expectTypeOf(manager.start()).toEqualTypeOf<Promise<void>>();
+		expectTypeOf(manager.start(1, 2)).toEqualTypeOf<Promise<void>>();
+		// @ts-expect-error - coordinates come off a DOM event, never as strings.
+		manager.start("1", "2");
+	});
+});
+
+describe("the harness fixtures match the shared types", () => {
+	test("they build the real shapes, not lookalikes", () => {
+		expectTypeOf(config()).toEqualTypeOf<ProcaptchaClientConfigInput>();
+		expectTypeOf(state()).toEqualTypeOf<ProcaptchaState>();
+		expectTypeOf(frictionless()).toEqualTypeOf<FrictionlessState>();
+	});
+});