@prosopo/procaptcha-common 2.9.23 → 2.10.18

package/src/tests/defaultCallbacks.test.ts

@@ -0,0 +1,372 @@
+// 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 type { ProcaptchaRenderOptions, ProcaptchaToken } from "@prosopo/types";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	getDefaultCallbacks,
+	setUserCallbacks,
+} from "../callbacks/defaultCallbacks.js";
+
+describe("callbacks/defaultCallbacks", () => {
+	beforeEach(() => {
+		document.body.innerHTML = "";
+		vi.clearAllMocks();
+	});
+
+	describe("getDefaultCallbacks", () => {
+		it("should return default callbacks object", () => {
+			const callbacks = getDefaultCallbacks();
+
+			expect(callbacks).toHaveProperty("onHuman");
+			expect(callbacks).toHaveProperty("onChallengeExpired");
+			expect(callbacks).toHaveProperty("onExtensionNotFound");
+			expect(callbacks).toHaveProperty("onExpired");
+			expect(callbacks).toHaveProperty("onError");
+			expect(callbacks).toHaveProperty("onClose");
+			expect(callbacks).toHaveProperty("onOpen");
+			expect(callbacks).toHaveProperty("onFailed");
+			expect(callbacks).toHaveProperty("onReset");
+			expect(callbacks).toHaveProperty("onReload");
+
+			expect(typeof callbacks.onHuman).toBe("function");
+			expect(typeof callbacks.onChallengeExpired).toBe("function");
+			expect(typeof callbacks.onError).toBe("function");
+		});
+
+		it("onHuman should add hidden input to form with token", () => {
+			const form = document.createElement("form");
+			const widget = document.createElement("div");
+			form.appendChild(widget);
+			document.body.appendChild(form);
+
+			const callbacks = getDefaultCallbacks(widget);
+			const token = "test-token-123" as ProcaptchaToken;
+
+			callbacks.onHuman(token);
+
+			const inputs = form.querySelectorAll(
+				`input[name="${ApiParams.procaptchaResponse}"]`,
+			);
+			expect(inputs.length).toBe(1);
+			expect((inputs[0] as HTMLInputElement).value).toBe(token);
+			expect((inputs[0] as HTMLInputElement).type).toBe("hidden");
+		});
+
+		it("onHuman should handle missing parent form gracefully", () => {
+			const widget = document.createElement("div");
+			document.body.appendChild(widget);
+
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+
+			const callbacks = getDefaultCallbacks(widget);
+			const token = "test-token-123" as ProcaptchaToken;
+
+			callbacks.onHuman(token);
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"Parent form not found for the element:",
+				widget,
+			);
+
+			consoleErrorSpy.mockRestore();
+		});
+
+		it("onChallengeExpired should remove procaptcha response", () => {
+			const input = document.createElement("input");
+			input.name = ApiParams.procaptchaResponse;
+			document.body.appendChild(input);
+
+			const callbacks = getDefaultCallbacks();
+			callbacks.onChallengeExpired();
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+		});
+
+		it("onExpired should remove procaptcha response", () => {
+			const input = document.createElement("input");
+			input.name = ApiParams.procaptchaResponse;
+			document.body.appendChild(input);
+
+			const callbacks = getDefaultCallbacks();
+			callbacks.onExpired();
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+		});
+
+		it("onError should remove procaptcha response and log error", () => {
+			const input = document.createElement("input");
+			input.name = ApiParams.procaptchaResponse;
+			document.body.appendChild(input);
+
+			const consoleErrorSpy = vi
+				.spyOn(console, "error")
+				.mockImplementation(() => {});
+			const callbacks = getDefaultCallbacks();
+			const error = new Error("Test error");
+
+			callbacks.onError(error);
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+			expect(consoleErrorSpy).toHaveBeenCalledWith(error);
+
+			consoleErrorSpy.mockRestore();
+		});
+
+		it("onFailed should show alert", () => {
+			const alertSpy = vi.spyOn(window, "alert").mockImplementation(() => {});
+			const callbacks = getDefaultCallbacks();
+
+			callbacks.onFailed();
+
+			expect(alertSpy).toHaveBeenCalledWith(
+				"Captcha challenge failed. Please try again",
+			);
+
+			alertSpy.mockRestore();
+		});
+
+		it("onReset should remove procaptcha response", () => {
+			const input = document.createElement("input");
+			input.name = ApiParams.procaptchaResponse;
+			document.body.appendChild(input);
+
+			const callbacks = getDefaultCallbacks();
+			callbacks.onReset();
+
+			expect(
+				document.getElementsByName(ApiParams.procaptchaResponse).length,
+			).toBe(0);
+		});
+	});
+
+	describe("setUserCallbacks", () => {
+		it("should wrap user callback for onHuman", () => {
+			const form = document.createElement("form");
+			const widget = document.createElement("div");
+			form.appendChild(widget);
+			document.body.appendChild(form);
+
+			const userCallback = vi.fn();
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				callback: userCallback,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			const token = "test-token" as ProcaptchaToken;
+			callbacks.onHuman(token);
+
+			expect(userCallback).toHaveBeenCalledWith(token);
+			// Also verify that default behavior (adding to form) still happens
+			const inputs = form.querySelectorAll(
+				`input[name="${ApiParams.procaptchaResponse}"]`,
+			);
+			expect(inputs.length).toBeGreaterThan(0);
+		});
+
+		it("should use data attribute callback over renderOptions", () => {
+			const form = document.createElement("form");
+			const widget = document.createElement("div");
+			form.appendChild(widget);
+			document.body.appendChild(form);
+
+			const dataCallback = vi.fn();
+			const renderCallback = vi.fn();
+
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).dataCallbackFn = dataCallback;
+			widget.setAttribute("data-callback", "dataCallbackFn");
+
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				callback: renderCallback,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			const token = "test-token" as ProcaptchaToken;
+			callbacks.onHuman(token);
+
+			expect(dataCallback).toHaveBeenCalledWith(token);
+			expect(renderCallback).not.toHaveBeenCalled();
+
+			// biome-ignore lint/suspicious/noExplicitAny: Test cleanup
+			(window as any).dataCallbackFn = undefined;
+		});
+
+		it("should handle string callback name in renderOptions", () => {
+			const form = document.createElement("form");
+			const widget = document.createElement("div");
+			form.appendChild(widget);
+			document.body.appendChild(form);
+
+			const namedCallback = vi.fn();
+			// biome-ignore lint/suspicious/noExplicitAny: Test setup
+			(window as any).myCallback = namedCallback;
+
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				// biome-ignore lint/suspicious/noExplicitAny: Test string callback
+				callback: "myCallback" as any,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			const token = "test-token" as ProcaptchaToken;
+			callbacks.onHuman(token);
+
+			expect(namedCallback).toHaveBeenCalledWith(token);
+
+			// biome-ignore lint/suspicious/noExplicitAny: Test cleanup
+			(window as any).myCallback = undefined;
+		});
+
+		it("should set expired callback from renderOptions", () => {
+			const widget = document.createElement("div");
+			const expiredCallback = vi.fn();
+
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				"expired-callback": expiredCallback,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			callbacks.onExpired();
+
+			expect(expiredCallback).toHaveBeenCalled();
+		});
+
+		it("should set error callback from renderOptions", () => {
+			const widget = document.createElement("div");
+			const errorCallback = vi.fn();
+
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				"error-callback": errorCallback,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			const error = new Error("Test error");
+			callbacks.onError(error);
+
+			expect(errorCallback).toHaveBeenCalledWith(error);
+		});
+
+		it("should set failed callback from renderOptions", () => {
+			const widget = document.createElement("div");
+			const failedCallback = vi.fn();
+
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				"failed-callback": failedCallback,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			callbacks.onFailed();
+
+			expect(failedCallback).toHaveBeenCalled();
+		});
+
+		it("should set reset callback from renderOptions", () => {
+			const widget = document.createElement("div");
+			const resetCallback = vi.fn();
+
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				"reset-callback": resetCallback,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			callbacks.onReset();
+
+			expect(resetCallback).toHaveBeenCalled();
+		});
+
+		it("should handle undefined renderOptions gracefully", () => {
+			const widget = document.createElement("div");
+			const callbacks = getDefaultCallbacks(widget);
+
+			expect(() =>
+				setUserCallbacks(undefined, callbacks, widget),
+			).not.toThrow();
+		});
+
+		it("should set open and close callbacks", () => {
+			const widget = document.createElement("div");
+			const openCallback = vi.fn();
+			const closeCallback = vi.fn();
+
+			const renderOptions: Partial<ProcaptchaRenderOptions> = {
+				"open-callback": openCallback,
+				"close-callback": closeCallback,
+			};
+
+			const callbacks = getDefaultCallbacks(widget);
+			setUserCallbacks(
+				renderOptions as ProcaptchaRenderOptions,
+				callbacks,
+				widget,
+			);
+
+			callbacks.onOpen();
+			callbacks.onClose();
+
+			expect(openCallback).toHaveBeenCalled();
+			expect(closeCallback).toHaveBeenCalled();
+		});
+	});
+});

package/src/tests/defaultEvents.test.ts

@@ -0,0 +1,80 @@
+// 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 { describe, expect, it, vi } from "vitest";
+import { getDefaultEvents } from "../callbacks/defaultEvents.js";
+
+describe("callbacks/defaultEvents", () => {
+	describe("getDefaultEvents", () => {
+		it("should merge default callbacks with provided callbacks", () => {
+			const customCallback = vi.fn();
+			const events = getDefaultEvents({
+				onHuman: customCallback,
+			});
+
+			expect(events.onHuman).toBe(customCallback);
+			expect(typeof events.onError).toBe("function");
+			expect(typeof events.onExpired).toBe("function");
+		});
+
+		it("should return all default callbacks when no custom callbacks provided", () => {
+			const events = getDefaultEvents({});
+
+			expect(typeof events.onHuman).toBe("function");
+			expect(typeof events.onChallengeExpired).toBe("function");
+			expect(typeof events.onExtensionNotFound).toBe("function");
+			expect(typeof events.onExpired).toBe("function");
+			expect(typeof events.onError).toBe("function");
+			expect(typeof events.onClose).toBe("function");
+			expect(typeof events.onOpen).toBe("function");
+			expect(typeof events.onFailed).toBe("function");
+			expect(typeof events.onReset).toBe("function");
+			expect(typeof events.onReload).toBe("function");
+		});
+
+		it("should allow overriding multiple callbacks", () => {
+			const customOnError = vi.fn();
+			const customOnExpired = vi.fn();
+			const customOnClose = vi.fn();
+
+			const events = getDefaultEvents({
+				onError: customOnError,
+				onExpired: customOnExpired,
+				onClose: customOnClose,
+			});
+
+			expect(events.onError).toBe(customOnError);
+			expect(events.onExpired).toBe(customOnExpired);
+			expect(events.onClose).toBe(customOnClose);
+			expect(typeof events.onHuman).toBe("function");
+			expect(typeof events.onFailed).toBe("function");
+		});
+
+		it("should preserve default behavior for non-overridden callbacks", () => {
+			const customOnHuman = vi.fn();
+
+			const events = getDefaultEvents({
+				onHuman: customOnHuman,
+			});
+
+			// Test that custom callback is used
+			expect(events.onHuman).toBe(customOnHuman);
+
+			// Test that other callbacks still exist and are functions
+			expect(typeof events.onError).toBe("function");
+			expect(typeof events.onExpired).toBe("function");
+			expect(typeof events.onChallengeExpired).toBe("function");
+		});
+	});
+});

package/src/tests/extensionLoader.test.ts

@@ -0,0 +1,41 @@
+// 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 { describe, expect, it, vi } from "vitest";
+import { ExtensionLoader } from "../extensionLoader.js";
+
+// Mock the imports
+vi.mock("@prosopo/account/extension/ExtensionWeb2", () => ({
+	default: { name: "ExtensionWeb2" },
+}));
+
+vi.mock("@prosopo/account/extension/ExtensionWeb3", () => ({
+	default: { name: "ExtensionWeb3" },
+}));
+
+describe("extensionLoader", () => {
+	describe("ExtensionLoader", () => {
+		it("should load ExtensionWeb2 when web2 is true", async () => {
+			const result = await ExtensionLoader(true);
+
+			expect(result).toEqual({ name: "ExtensionWeb2" });
+		});
+
+		it("should load ExtensionWeb3 when web2 is false", async () => {
+			const result = await ExtensionLoader(false);
+
+			expect(result).toEqual({ name: "ExtensionWeb3" });
+		});
+	});
+});

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);
+		});
+	});
+});