@prosopo/procaptcha-pow 2.13.7 → 2.13.8

package/src/tests/managerHarness.ts

@@ -1,135 +0,0 @@
-// 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

@@ -1,143 +0,0 @@
-// 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 { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import type { ProcaptchaPowHandle } from "../components/procaptchaWidget.js";
-import * as entrypoint from "../index.js";
-import { type Mounted, mount, settle } from "./domHarness.js";
-import { config } from "./managerHarness.js";
-
-/**
- * The outer entry point 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[],
-	destroyed: { count: 0 },
-}));
-
-vi.mock("../components/procaptchaWidget.js", () => ({
-	mountProcaptchaPowWidget: (
-		container: HTMLElement,
-		props: ProcaptchaProps,
-	): ProcaptchaPowHandle => {
-		mocks.received.push(props);
-		const element = document.createElement("div");
-		element.setAttribute("data-testid", "widget");
-		container.appendChild(element);
-		return {
-			destroy: () => {
-				element.remove();
-				mocks.destroyed.count += 1;
-			},
-		};
-	},
-}));
-
-let mounted: Mounted;
-let widget: ProcaptchaPowHandle | undefined;
-
-const props = (overrides: Partial<ProcaptchaProps> = {}): ProcaptchaProps => ({
-	config: config(),
-	callbacks: {},
-	i18n: undefined as unknown as Ti18n,
-	...overrides,
-});
-
-const render = async (widgetProps: ProcaptchaProps): Promise<void> => {
-	widget = entrypoint.mountProcaptchaPow(mounted.container, widgetProps);
-	await settle();
-};
-
-beforeEach(() => {
-	mocks.received.length = 0;
-	mocks.destroyed.count = 0;
-	widget = undefined;
-	mounted = mount();
-});
-
-afterEach(() => {
-	widget?.destroy();
-	widget = undefined;
-	mounted.unmount();
-});
-
-describe("mountProcaptchaPow", () => {
-	test("renders the widget once it has loaded", async () => {
-		await render(props());
-		expect(
-			mounted.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());
-	});
-
-	test("tears the loaded widget down", async () => {
-		await render(props());
-		widget?.destroy();
-		widget = undefined;
-		expect(mocks.destroyed.count).toBe(1);
-		expect(
-			mounted.container.querySelector('[data-testid="widget"]'),
-		).toBeNull();
-	});
-
-	test("cancels a mount that is still loading", async () => {
-		// Otherwise a widget torn down mid-load reappears as an orphan that
-		// nothing holds a handle to.
-		widget = entrypoint.mountProcaptchaPow(mounted.container, props());
-		widget.destroy();
-		widget = undefined;
-		await settle();
-		expect(mocks.received).toHaveLength(0);
-	});
-});
-
-describe("the package entrypoint", () => {
-	test("exports the mount functions a consumer needs", () => {
-		expect(typeof entrypoint.mountProcaptchaPow).toBe("function");
-		expect(typeof entrypoint.loadProcaptchaPow).toBe("function");
-		expect(typeof entrypoint.mountProcaptchaPowWidget).toBe("function");
-	});
-});

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

@@ -1,128 +0,0 @@
-// 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 { assertType, describe, expectTypeOf, test } from "vitest";
-import type * as entrypoint from "../index.js";
-import { mountProcaptchaPow } 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("mountProcaptchaPow takes a host element and the shared widget props", () => {
-		expectTypeOf(mountProcaptchaPow).parameters.toEqualTypeOf<
-			[HTMLElement, ProcaptchaProps]
-		>();
-		expectTypeOf(mountProcaptchaPow).returns.toExtend<{
-			destroy: () => void;
-		}>();
-	});
-
-	test("the entrypoint exposes the lazy wrapper and the widget itself", () => {
-		// The lazy wrapper is what works without a code-splitting bundler; the
-		// direct mount is what ProcaptchaFrictionless imports once it has already
-		// paid for the dynamic import of this package.
-		expectTypeOf<keyof typeof entrypoint>().toEqualTypeOf<
-			"mountProcaptchaPow" | "loadProcaptchaPow" | "mountProcaptchaPowWidget"
-		>();
-	});
-
-	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, resetState and dispose", () => {
-		expectTypeOf<keyof ReturnType<typeof Manager>>().toEqualTypeOf<
-			"start" | "resetState" | "dispose"
-		>();
-		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>();
-	});
-});