@intuned/runtime 1.3.18-interface.7 → 1.3.18

package/dist/runtime/captcha.test.js

@@ -0,0 +1,821 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _intunedExtensionServer = require("../common/extension/intunedExtensionServer");
+var _captcha = require("./captcha");
+_vitest.vi.mock("fastify", () => {
+  const fastify = () => ({
+    post: _vitest.vi.fn(),
+    setNotFoundHandler: _vitest.vi.fn(),
+    listen: _vitest.vi.fn(async () => undefined),
+    close: _vitest.vi.fn(async () => undefined)
+  });
+  return {
+    default: fastify
+  };
+});
+let server;
+_vitest.vi.mock("../common/extension/intunedExtensionServer", async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    getIntunedExtensionServer: () => server,
+    getTabId: _vitest.vi.fn(async () => 0)
+  };
+});
+function makeMockPage() {
+  return {
+    waitForLoadState: _vitest.vi.fn().mockResolvedValue(undefined),
+    waitForFunction: _vitest.vi.fn().mockResolvedValue(undefined),
+    evaluate: _vitest.vi.fn().mockResolvedValue(0)
+  };
+}
+async function runCaptchaTestScenario({
+  page,
+  mockStates,
+  timeoutMs = 10000,
+  settleDurationMs = 100,
+  expectErrorCode,
+  expectTimeout = false
+}) {
+  for (const state of mockStates) {
+    await server.handleUpsertCaptcha(state.initial);
+  }
+  const allTransitions = [];
+  for (const state of mockStates) {
+    for (const transition of state.transitions) {
+      allTransitions.push({
+        timeMs: transition.timeMs,
+        captchaId: state.initial.id,
+        type: state.initial.type,
+        status: transition.status,
+        errorCode: transition.errorCode
+      });
+    }
+  }
+  allTransitions.sort((a, b) => a.timeMs - b.timeMs);
+  const p = (0, _captcha.waitForCaptchaSolve)(page, {
+    timeoutInMs: timeoutMs,
+    settleDurationMs
+  });
+  let assertion;
+  if (expectErrorCode) {
+    assertion = (0, _vitest.expect)(p).rejects.toThrow(`CAPTCHA Solve Error: ${expectErrorCode}`);
+  } else if (expectTimeout) {
+    assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve timed out with pending captchas.");
+  }
+  await _vitest.vi.advanceTimersByTimeAsync(0);
+  let currentTimeMs = 0;
+  for (const transition of allTransitions) {
+    const deltaMs = transition.timeMs - currentTimeMs;
+    if (deltaMs > 0) {
+      await _vitest.vi.advanceTimersByTimeAsync(deltaMs);
+      currentTimeMs = transition.timeMs;
+    }
+    const captcha = transition.status === "error" && transition.errorCode ? {
+      id: transition.captchaId,
+      tabId: 0,
+      type: transition.type,
+      status: "error",
+      error: {
+        code: transition.errorCode
+      }
+    } : {
+      id: transition.captchaId,
+      tabId: 0,
+      type: transition.type,
+      status: transition.status
+    };
+    await server.handleUpsertCaptcha(captcha);
+  }
+  await _vitest.vi.advanceTimersByTimeAsync(settleDurationMs + 10);
+  if (expectTimeout || expectErrorCode) {
+    await _vitest.vi.advanceTimersByTimeAsync(timeoutMs + settleDurationMs);
+  }
+  if (assertion) {
+    await assertion;
+  } else {
+    await (0, _vitest.expect)(p).resolves.toBeUndefined();
+  }
+}
+(0, _vitest.beforeEach)(() => {
+  _vitest.vi.useFakeTimers();
+  server = new _intunedExtensionServer.ExtensionServer();
+});
+(0, _vitest.afterEach)(() => {
+  _vitest.vi.useRealTimers();
+  _vitest.vi.restoreAllMocks();
+});
+(0, _vitest.describe)("runtime/captcha", () => {
+  (0, _vitest.it)("waitForCaptchaSolve: resolves after settle period when no captchas are present", async () => {
+    const page = makeMockPage();
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settleDurationMs: 10
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await p;
+    (0, _vitest.expect)(page.waitForLoadState).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("withWaitForCaptchaSolve: preserves return value and waits for networkidle by default", async () => {
+    const page = makeMockPage();
+    const p = (0, _captcha.withWaitForCaptchaSolve)(async () => "ok", {
+      page,
+      timeoutInMs: 1000,
+      settleDurationMs: 10
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBe("ok");
+    (0, _vitest.expect)(page.waitForLoadState).toHaveBeenCalledWith("networkidle");
+  });
+  (0, _vitest.it)("withWaitForCaptchaSolve: skips networkidle when disabled", async () => {
+    const page = makeMockPage();
+    const p = (0, _captcha.withWaitForCaptchaSolve)(async () => "ok", {
+      page,
+      timeoutInMs: 1000,
+      settleDurationMs: 10,
+      waitForNetworkSettled: false
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBe("ok");
+    (0, _vitest.expect)(page.waitForLoadState).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: completes when a solving captcha becomes solved", async () => {
+    const page = makeMockPage();
+    await server.handleUpsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    });
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settleDurationMs: 10
+    });
+    await Promise.resolve();
+    await server.handleUpsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solved",
+      retryCount: 0
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBeUndefined();
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: throws on captcha error", async () => {
+    const page = makeMockPage();
+    await server.handleUpsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    });
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settleDurationMs: 10
+    });
+    const assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve Error: UNEXPECTED_ERROR");
+    await _vitest.vi.advanceTimersByTimeAsync(0);
+    await server.handleUpsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "error",
+      retryCount: 0,
+      error: {
+        code: "UNEXPECTED_ERROR"
+      }
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await assertion;
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: times out if captchas are still pending", async () => {
+    const page = makeMockPage();
+    await server.handleUpsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    });
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 5,
+      settleDurationMs: 1
+    });
+    const assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve timed out with pending captchas.");
+    await Promise.resolve();
+    await _vitest.vi.advanceTimersByTimeAsync(6);
+    await _vitest.vi.advanceTimersByTimeAsync(1);
+    await assertion;
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: waits for all captchas to resolve", async () => {
+    const page = makeMockPage();
+    await server.handleUpsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    });
+    await server.handleUpsertCaptcha({
+      id: "c2",
+      tabId: 0,
+      type: "hcaptcha",
+      status: "solving",
+      retryCount: 0
+    });
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settleDurationMs: 10
+    });
+    await Promise.resolve();
+    await server.handleUpsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solved",
+      retryCount: 0
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    let settled = false;
+    p.then(() => settled = true).catch(() => settled = true);
+    await Promise.resolve();
+    (0, _vitest.expect)(settled).toBe(false);
+    await server.handleUpsertCaptcha({
+      id: "c2",
+      tabId: 0,
+      type: "hcaptcha",
+      status: "detached",
+      retryCount: 0
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBeUndefined();
+  });
+  (0, _vitest.describe)("captchaStateTransitions", () => {
+    (0, _vitest.it)("captcha detached completes successfully", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "test1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("attached to solving to solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 350,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("attached to detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("attached to solving to error", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 550,
+            status: "error",
+            errorCode: "UNEXPECTED_ERROR"
+          }]
+        }],
+        settleDurationMs: 100,
+        expectErrorCode: "UNEXPECTED_ERROR"
+      });
+    });
+    (0, _vitest.it)("attached to solving to detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 200,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("visibility toggle then solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 120,
+            status: "solving"
+          }, {
+            timeMs: 420,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("visibility toggle then error", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 120,
+            status: "solving"
+          }, {
+            timeMs: 620,
+            status: "error",
+            errorCode: "MAX_RETRIES"
+          }]
+        }],
+        settleDurationMs: 100,
+        expectErrorCode: "MAX_RETRIES"
+      });
+    });
+    (0, _vitest.it)("visibility toggle then detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 110,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("visibility toggle solving then detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 100,
+            status: "attached"
+          }, {
+            timeMs: 120,
+            status: "solving"
+          }, {
+            timeMs: 270,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("rapid visibility toggle then solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 60,
+            status: "attached"
+          }, {
+            timeMs: 65,
+            status: "solving"
+          }, {
+            timeMs: 75,
+            status: "attached"
+          }, {
+            timeMs: 80,
+            status: "solving"
+          }, {
+            timeMs: 380,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("rapid visibility toggle then detached", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 50,
+            status: "solving"
+          }, {
+            timeMs: 60,
+            status: "attached"
+          }, {
+            timeMs: 65,
+            status: "solving"
+          }, {
+            timeMs: 75,
+            status: "attached"
+          }, {
+            timeMs: 80,
+            status: "detached"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("instant toggles then solved", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 1,
+            status: "solving"
+          }, {
+            timeMs: 2,
+            status: "attached"
+          }, {
+            timeMs: 3,
+            status: "solving"
+          }, {
+            timeMs: 300,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("long solving timeout", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "attached"
+          },
+          transitions: [{
+            timeMs: 10,
+            status: "solving"
+          }, {
+            timeMs: 30000,
+            status: "error",
+            errorCode: "UNEXPECTED_ERROR"
+          }]
+        }],
+        timeoutMs: 10000,
+        settleDurationMs: 3000,
+        expectTimeout: true
+      });
+    });
+    (0, _vitest.it)("multiple captchas both solve", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "solved"
+          }]
+        }, {
+          initial: {
+            id: "captcha2",
+            tabId: 0,
+            type: "hcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 200,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+    (0, _vitest.it)("multiple captchas one errors", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: []
+        }, {
+          initial: {
+            id: "captcha2",
+            tabId: 0,
+            type: "hcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "error",
+            errorCode: "HIT_LIMIT"
+          }]
+        }],
+        settleDurationMs: 100,
+        expectErrorCode: "HIT_LIMIT"
+      });
+    });
+    (0, _vitest.it)("staggered captcha resolution", async () => {
+      const page = makeMockPage();
+      await runCaptchaTestScenario({
+        page,
+        mockStates: [{
+          initial: {
+            id: "captcha1",
+            tabId: 0,
+            type: "recaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 100,
+            status: "solved"
+          }]
+        }, {
+          initial: {
+            id: "captcha2",
+            tabId: 0,
+            type: "hcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 200,
+            status: "detached"
+          }]
+        }, {
+          initial: {
+            id: "captcha3",
+            tabId: 0,
+            type: "funcaptcha",
+            status: "solving"
+          },
+          transitions: [{
+            timeMs: 300,
+            status: "solved"
+          }]
+        }],
+        settleDurationMs: 100
+      });
+    });
+  });
+  (0, _vitest.describe)("onCaptchaEvent", () => {
+    (0, _vitest.it)("calls callback for matching status", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c1");
+      (0, _vitest.expect)(receivedCaptchas[0].status).toBe("solved");
+    });
+    (0, _vitest.it)("ignores non-matching status", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solving"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(0);
+    });
+    (0, _vitest.it)("calls callback multiple times for multiple matching events", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "hcaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(2);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c1");
+      (0, _vitest.expect)(receivedCaptchas[1].id).toBe("c2");
+    });
+  });
+  (0, _vitest.describe)("onceCaptchaEvent", () => {
+    (0, _vitest.it)("calls callback only once for first matching event", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onceCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "hcaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c1");
+    });
+    (0, _vitest.it)("receives all events until first match, then unsubscribes", async () => {
+      const page = makeMockPage();
+      const receivedCaptchas = [];
+      await (0, _captcha.onceCaptchaEvent)(page, "solved", async captcha => {
+        receivedCaptchas.push(captcha);
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solving"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(0);
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+      (0, _vitest.expect)(receivedCaptchas[0].id).toBe("c2");
+      await server.handleUpsertCaptcha({
+        id: "c3",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(receivedCaptchas).toHaveLength(1);
+    });
+    (0, _vitest.it)("unsubscribes after first matching event", async () => {
+      const page = makeMockPage();
+      let callCount = 0;
+      await (0, _captcha.onceCaptchaEvent)(page, "solved", async () => {
+        callCount++;
+      });
+      await server.handleUpsertCaptcha({
+        id: "c1",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(callCount).toBe(1);
+      await server.handleUpsertCaptcha({
+        id: "c2",
+        tabId: 0,
+        type: "recaptcha",
+        status: "solved"
+      });
+      (0, _vitest.expect)(callCount).toBe(1);
+    });
+  });
+});