@prosopo/procaptcha-common 2.9.19 → 2.10.17

package/src/tests/form.test.ts

@@ -0,0 +1,154 @@
+// 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 { ApiParams } from "@prosopo/types";
+import { beforeEach, describe, expect, it } from "vitest";
+import { getParentForm, removeProcaptchaResponse } from "../elements/form.js";
+
+describe("elements/form", () => {
+	describe("getParentForm", () => {
+		beforeEach(() => {
+			document.body.innerHTML = "";
+		});
+
+		it("should find parent form for regular DOM element", () => {
+			const form = document.createElement("form");
+			const div = document.createElement("div");
+			const widget = document.createElement("div");
+
+			form.appendChild(div);
+			div.appendChild(widget);
+			document.body.appendChild(form);
+
+			const result = getParentForm(widget);
+			expect(result).toBe(form);
+		});
+
+		it("should return null if no parent form exists", () => {
+			const widget = document.createElement("div");
+			document.body.appendChild(widget);
+
+			const result = getParentForm(widget);
+			expect(result).toBeNull();
+		});
+
+		it("should find parent form for element in shadow DOM", () => {
+			const form = document.createElement("form");
+			const host = document.createElement("div");
+			const shadowRoot = host.attachShadow({ mode: "open" });
+			const widget = document.createElement("div");
+
+			shadowRoot.appendChild(widget);
+			form.appendChild(host);
+			document.body.appendChild(form);
+
+			const result = getParentForm(widget);
+			expect(result).toBe(form);
+		});
+
+		it("should handle nested forms and return closest one", () => {
+			const outerForm = document.createElement("form");
+			outerForm.id = "outer";
+			const innerForm = document.createElement("form");
+			innerForm.id = "inner";
+			const widget = document.createElement("div");
+
+			innerForm.appendChild(widget);
+			outerForm.appendChild(innerForm);
+			document.body.appendChild(outerForm);
+
+			const result = getParentForm(widget);
+			expect(result).toBe(innerForm);
+		});
+	});
+
+	describe("removeProcaptchaResponse", () => {
+		beforeEach(() => {
+			document.body.innerHTML = "";
+		});
+
+		it("should remove all procaptcha response elements", () => {
+			const input1 = document.createElement("input");
+			input1.name = ApiParams.procaptchaResponse;
+			input1.value = "token1";
+
+			const input2 = document.createElement("input");
+			input2.name = ApiParams.procaptchaResponse;
+			input2.value = "token2";
+
+			document.body.appendChild(input1);
+			document.body.appendChild(input2);
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(2);
+
+			removeProcaptchaResponse();
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+		});
+
+		it("should not remove other input elements", () => {
+			const procaptchaInput = document.createElement("input");
+			procaptchaInput.name = ApiParams.procaptchaResponse;
+
+			const otherInput = document.createElement("input");
+			otherInput.name = "other-field";
+
+			document.body.appendChild(procaptchaInput);
+			document.body.appendChild(otherInput);
+
+			removeProcaptchaResponse();
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+			expect(document.getElementsByName("other-field").length).toBe(1);
+		});
+
+		it("should handle case when no procaptcha response elements exist", () => {
+			expect(() => removeProcaptchaResponse()).not.toThrow();
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+		});
+
+		it("should remove elements from different parts of the DOM", () => {
+			const form1 = document.createElement("form");
+			const input1 = document.createElement("input");
+			input1.name = ApiParams.procaptchaResponse;
+			form1.appendChild(input1);
+
+			const form2 = document.createElement("form");
+			const input2 = document.createElement("input");
+			input2.name = ApiParams.procaptchaResponse;
+			form2.appendChild(input2);
+
+			document.body.appendChild(form1);
+			document.body.appendChild(form2);
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(2);
+
+			removeProcaptchaResponse();
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+		});
+	});
+});

package/src/tests/providers.test.ts

@@ -0,0 +1,175 @@
+// 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 { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	getProcaptchaRandomActiveProvider,
+	providerRetry,
+} from "../providers.js";
+
+// Mock the load-balancer module
+vi.mock("@prosopo/load-balancer", () => ({
+	getRandomActiveProvider: vi.fn(),
+}));
+
+describe("providers", () => {
+	describe("getProcaptchaRandomActiveProvider", () => {
+		// biome-ignore lint/suspicious/noExplicitAny: Store original crypto function
+		let originalGetRandomValues: any;
+
+		beforeEach(() => {
+			originalGetRandomValues = global.window.crypto.getRandomValues.bind(
+				global.window.crypto,
+			);
+		});
+
+		afterEach(() => {
+			global.window.crypto.getRandomValues = originalGetRandomValues;
+		});
+
+		it("should generate random values and call getRandomActiveProvider", async () => {
+			// Mock window.crypto.getRandomValues
+			const mockRandomValues = new Uint8Array([
+				10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
+			]);
+			const mockGetRandomValues = vi.fn(() => mockRandomValues);
+			// biome-ignore lint/suspicious/noExplicitAny: Mock crypto API
+			global.window.crypto.getRandomValues = mockGetRandomValues as any;
+
+			// Mock the getRandomActiveProvider import
+			const { getRandomActiveProvider } = await import(
+				"@prosopo/load-balancer"
+			);
+			vi.mocked(getRandomActiveProvider).mockResolvedValue({
+				providerUrl: "https://test-provider.com",
+				// biome-ignore lint/suspicious/noExplicitAny: Mock return type
+			} as any);
+
+			const result = await getProcaptchaRandomActiveProvider("development");
+
+			expect(mockGetRandomValues).toHaveBeenCalledWith(expect.any(Uint8Array));
+			expect(getRandomActiveProvider).toHaveBeenCalledWith("development", 550); // sum of mockRandomValues
+			expect(result).toEqual({ providerUrl: "https://test-provider.com" });
+		});
+
+		it("should use different random values on each call", async () => {
+			let callCount = 0;
+			const mockGetRandomValues = vi.fn((arr: Uint8Array) => {
+				callCount++;
+				arr.fill(callCount);
+				return arr;
+			});
+			// biome-ignore lint/suspicious/noExplicitAny: Mock crypto API
+			global.window.crypto.getRandomValues = mockGetRandomValues as any;
+
+			const { getRandomActiveProvider } = await import(
+				"@prosopo/load-balancer"
+			);
+			// biome-ignore lint/suspicious/noExplicitAny: Mock return type
+			vi.mocked(getRandomActiveProvider).mockResolvedValue({} as any);
+
+			await getProcaptchaRandomActiveProvider("development");
+			await getProcaptchaRandomActiveProvider("development");
+
+			expect(mockGetRandomValues).toHaveBeenCalledTimes(2);
+		});
+	});
+
+	describe("providerRetry", () => {
+		it("should successfully execute currentFn without retrying", async () => {
+			const currentFn = vi.fn().mockResolvedValue(undefined);
+			const retryFn = vi.fn();
+			const stateReset = vi.fn();
+
+			await providerRetry(currentFn, retryFn, stateReset, 0, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(retryFn).not.toHaveBeenCalled();
+			expect(stateReset).not.toHaveBeenCalled();
+		});
+
+		it("should call retryFn when currentFn fails and attempts are below max", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn().mockResolvedValue(undefined);
+			const stateReset = vi.fn();
+
+			await providerRetry(currentFn, retryFn, stateReset, 1, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).toHaveBeenCalledTimes(1);
+		});
+
+		it("should call stateReset and not retry when max retries reached", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn();
+			const stateReset = vi.fn();
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+
+			await providerRetry(currentFn, retryFn, stateReset, 3, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).not.toHaveBeenCalled();
+			expect(consoleErrorSpy).toHaveBeenCalledWith(error);
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"Max retries (3 of 3) reached, aborting",
+			);
+
+			consoleErrorSpy.mockRestore();
+		});
+
+		it("should call stateReset and not retry when attempts exceed max", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn();
+			const stateReset = vi.fn();
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+
+			await providerRetry(currentFn, retryFn, stateReset, 5, 3);
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).not.toHaveBeenCalled();
+
+			consoleErrorSpy.mockRestore();
+		});
+
+		it("should reset state even when retryFn fails", async () => {
+			const error = new Error("Provider failed");
+			const currentFn = vi.fn().mockRejectedValue(error);
+			const retryFn = vi.fn().mockRejectedValue(new Error("Retry failed"));
+			const stateReset = vi.fn();
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+
+			await expect(
+				providerRetry(currentFn, retryFn, stateReset, 1, 3),
+			).rejects.toThrow("Retry failed");
+
+			expect(currentFn).toHaveBeenCalledTimes(1);
+			expect(stateReset).toHaveBeenCalledTimes(1);
+			expect(retryFn).toHaveBeenCalledTimes(1);
+
+			consoleErrorSpy.mockRestore();
+		});
+	});
+});

package/src/tests/state-builder.test.ts

@@ -0,0 +1,264 @@
+// 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 { ProcaptchaState } from "@prosopo/types";
+import { describe, expect, it, vi } from "vitest";
+import { buildUpdateState, useProcaptcha } from "../state/builder.js";
+
+describe("state/builder", () => {
+	describe("buildUpdateState", () => {
+		it("should mutate state and call onStateUpdate with partial state", () => {
+			const state: ProcaptchaState = {
+				isHuman: false,
+				index: 0,
+				solutions: [],
+				captchaApi: undefined,
+				showModal: false,
+				challenge: undefined,
+				loading: false,
+				account: undefined,
+				dappAccount: undefined,
+				submission: undefined,
+				timeout: undefined,
+				successfullChallengeTimeout: undefined,
+				sendData: false,
+				attemptCount: 0,
+				error: undefined,
+				sessionId: undefined,
+			};
+
+			const onStateUpdate = vi.fn();
+			const updateState = buildUpdateState(state, onStateUpdate);
+
+			const partialState = { isHuman: true, attemptCount: 1 };
+			updateState(partialState);
+
+			expect(state.isHuman).toBe(true);
+			expect(state.attemptCount).toBe(1);
+			expect(onStateUpdate).toHaveBeenCalledWith(partialState);
+		});
+
+		it("should handle multiple property updates in order", () => {
+			const state: ProcaptchaState = {
+				isHuman: false,
+				index: 0,
+				solutions: [],
+				captchaApi: undefined,
+				showModal: false,
+				challenge: undefined,
+				loading: false,
+				account: undefined,
+				dappAccount: undefined,
+				submission: undefined,
+				timeout: undefined,
+				successfullChallengeTimeout: undefined,
+				sendData: false,
+				attemptCount: 0,
+				error: undefined,
+				sessionId: undefined,
+			};
+
+			const onStateUpdate = vi.fn();
+			const updateState = buildUpdateState(state, onStateUpdate);
+
+			updateState({ loading: true, index: 5, showModal: true });
+
+			expect(state.loading).toBe(true);
+			expect(state.index).toBe(5);
+			expect(state.showModal).toBe(true);
+		});
+
+		it("should update error state correctly", () => {
+			const state: ProcaptchaState = {
+				isHuman: false,
+				index: 0,
+				solutions: [],
+				captchaApi: undefined,
+				showModal: false,
+				challenge: undefined,
+				loading: false,
+				account: undefined,
+				dappAccount: undefined,
+				submission: undefined,
+				timeout: undefined,
+				successfullChallengeTimeout: undefined,
+				sendData: false,
+				attemptCount: 0,
+				error: undefined,
+				sessionId: undefined,
+			};
+
+			const onStateUpdate = vi.fn();
+			const updateState = buildUpdateState(state, onStateUpdate);
+
+			const errorObj = { message: "Test error", key: "test" };
+			updateState({ error: errorObj });
+
+			expect(state.error).toEqual(errorObj);
+			expect(onStateUpdate).toHaveBeenCalledWith({ error: errorObj });
+		});
+	});
+
+	describe("useProcaptcha", () => {
+		it("should initialize with default state values", () => {
+			const useState = vi.fn((defaultValue) => [defaultValue, vi.fn()]);
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			expect(state.isHuman).toBe(false);
+			expect(state.index).toBe(0);
+			expect(state.solutions).toEqual([]);
+			expect(state.showModal).toBe(false);
+			expect(state.loading).toBe(false);
+			expect(state.sendData).toBe(false);
+			expect(state.attemptCount).toBe(0);
+			expect(state.account).toBeUndefined();
+			expect(state.captchaApi).toBeUndefined();
+			expect(state.challenge).toBeUndefined();
+			expect(state.error).toBeUndefined();
+			expect(typeof updateFn).toBe("function");
+		});
+
+		it("should call appropriate setters when updating state", () => {
+			// biome-ignore lint/suspicious/noExplicitAny: Mock setter functions
+			const setters: Record<string, any> = {};
+
+			const useState = vi.fn((defaultValue) => {
+				// Create a unique key based on the type and value to track different state variables
+				const key =
+					typeof defaultValue === "boolean"
+						? `boolean-${defaultValue}`
+						: typeof defaultValue === "number"
+							? `number-${defaultValue}`
+							: Array.isArray(defaultValue)
+								? "array"
+								: "other";
+
+				if (!setters[key]) {
+					setters[key] = vi.fn();
+				}
+				return [defaultValue, setters[key]];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			updateFn({
+				isHuman: true,
+				index: 5,
+				loading: true,
+				attemptCount: 3,
+			});
+
+			// Check that setters were called
+			// isHuman setter (boolean-false)
+			expect(setters["boolean-false"]).toHaveBeenCalledWith(true);
+			// index and attemptCount setters (both number-0)
+			expect(setters["number-0"]).toHaveBeenCalledWith(5);
+			expect(setters["number-0"]).toHaveBeenCalledWith(3);
+		});
+
+		it("should handle solutions array correctly with slice", () => {
+			const setSolutions = vi.fn();
+			// biome-ignore lint/suspicious/noExplicitAny: Mock solutions array
+			let solutionsValue: any[] = [];
+
+			const useState = vi.fn((defaultValue) => {
+				if (Array.isArray(defaultValue)) {
+					return [
+						solutionsValue,
+						// biome-ignore lint/suspicious/noExplicitAny: Mock setter function
+						(newValue: any) => {
+							solutionsValue = newValue;
+							setSolutions(newValue);
+						},
+					];
+				}
+				return [defaultValue, vi.fn()];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			const newSolutions: [string, number, number][][] = [[["test", 1, 2]]];
+			updateFn({ solutions: newSolutions });
+
+			expect(setSolutions).toHaveBeenCalled();
+			// Verify that slice was called by checking that we got a new array reference
+			const callArg = setSolutions.mock.calls[0]?.[0];
+			expect(callArg).toBeDefined();
+			expect(callArg).not.toBe(newSolutions);
+			expect(callArg).toEqual(newSolutions);
+		});
+
+		it("should not call setters for undefined values in partial update", () => {
+			const setIsHuman = vi.fn();
+			const setIndex = vi.fn();
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock setter tracking
+			let isHumanSetter: any;
+			// biome-ignore lint/suspicious/noExplicitAny: Mock setter tracking
+			let indexSetter: any;
+
+			const useState = vi.fn((defaultValue) => {
+				if (defaultValue === false) {
+					isHumanSetter = setIsHuman;
+					return [false, setIsHuman];
+				}
+				if (defaultValue === 0) {
+					indexSetter = setIndex;
+					return [0, setIndex];
+				}
+				return [defaultValue, vi.fn()];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			updateFn({ isHuman: true });
+
+			expect(setIsHuman).toHaveBeenCalledWith(true);
+			expect(setIndex).not.toHaveBeenCalled();
+		});
+
+		it("should handle error state update", () => {
+			const setError = vi.fn();
+
+			const useState = vi.fn((defaultValue) => {
+				if (defaultValue === undefined && setError.mock.calls.length === 0) {
+					return [undefined, setError];
+				}
+				return [defaultValue, vi.fn()];
+			});
+
+			const useRef = vi.fn((defaultValue) => ({ current: defaultValue }));
+
+			// biome-ignore lint/suspicious/noExplicitAny: Mock useState/useRef functions
+			const [state, updateFn] = useProcaptcha(useState as any, useRef as any);
+
+			const errorObj = { message: "Test error", key: "testKey" };
+			updateFn({ error: errorObj });
+
+			expect(setError).toHaveBeenCalledWith(errorObj);
+		});
+	});
+});