@intuned/runtime 1.3.17 → 1.3.18-interface.7

package/dist/runtime/captcha.test.js

@@ -1,821 +0,0 @@
-"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);
-    });
-  });
-});