@intuned/runtime-dev 1.3.0-dev-52 → 1.3.1-api-token.0

package/dist/commands/intuned-cli/controller/__test__/authSession.test.js

@@ -0,0 +1,676 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _authSession = require("../authSession");
+var _helpers = require("../../helpers");
+var _neverthrow = require("neverthrow");
+var _runApi = require("../../../../common/runApi");
+const _checkPassedResult = (0, _neverthrow.ok)({
+  result: true
+});
+const _checkFailedResult = (0, _neverthrow.ok)({
+  result: false
+});
+const _errorResult = (0, _neverthrow.err)(new _runApi.AutomationError("failed"));
+function _createSuccessResult(session) {
+  return (0, _neverthrow.ok)({
+    session
+  });
+}
+function getTerminal() {
+  return new Proxy(() => ({}), {
+    get: () => getTerminal(),
+    apply: () => ({})
+  });
+}
+_vitest.vi.mock("fs-extra", () => ({
+  writeJSON: _vitest.vi.fn()
+}));
+_vitest.vi.mock("../../../../common/runApi", async importOriginal => {
+  const original = await importOriginal();
+  return {
+    ...original,
+    runApi: _vitest.vi.fn().mockImplementation(() => (0, _neverthrow.ok)({}))
+  };
+});
+_vitest.vi.mock("../../helpers/terminal", () => ({
+  terminal: getTerminal()
+}));
+_vitest.vi.mock("../../helpers", async importOriginal => {
+  const original = await importOriginal();
+  return {
+    ...original,
+    terminal: getTerminal(),
+    assertApiFileExists: _vitest.vi.fn(),
+    withCLIContext: _vitest.vi.fn(fn => fn()),
+    withTimeout: _vitest.vi.fn(fn => fn()),
+    parseUrlProxy: _vitest.vi.fn(),
+    loadAuthSessionInstance: _vitest.vi.fn(),
+    storeAuthSessionInstance: _vitest.vi.fn().mockResolvedValue("authSessionInstancePath"),
+    registerGetAuthSessionParameters: _vitest.vi.fn()
+  };
+});
+(0, _vitest.describe)("Auth session controller", () => {
+  (0, _vitest.beforeEach)(() => {
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _vitest.describe)("runCheck", () => {
+    (0, _vitest.it)("calls timeout middleware with timeout", async () => {
+      await (0, _authSession._runCheck)({
+        auth: "session",
+        headless: false,
+        timeout: 6000
+      });
+      (0, _vitest.expect)(_helpers.withTimeout).toHaveBeenCalledWith(_vitest.expect.any(Function), 6000);
+    });
+    (0, _vitest.it)("calls runApi with correct parameters and parses proxy", async () => {
+      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
+      await (0, _authSession._runCheck)({
+        auth: "session",
+        headless: "headless",
+        timeout: 999999999,
+        proxy: "proxy"
+      });
+      (0, _vitest.expect)(_helpers.parseUrlProxy).toHaveBeenCalledWith("proxy");
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        automationFunction: {
+          name: "auth-sessions/check"
+        },
+        runOptions: {
+          headless: "headless",
+          environment: "standalone",
+          proxy: "parsed-proxy"
+        },
+        auth: _vitest.expect.objectContaining({
+          session: {
+            type: "state",
+            state: "session"
+          }
+        })
+      }));
+    });
+    (0, _vitest.it)("returns if check returns", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
+      const resultTrue = await (0, _authSession._runCheck)({
+        auth: "session",
+        headless: "headless",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(resultTrue).toEqual(true);
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult);
+      const resultFalse = await (0, _authSession._runCheck)({
+        auth: "session",
+        headless: "headless",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(resultFalse).toEqual(false);
+    });
+    (0, _vitest.it)("throws the error check fails with an error", async () => {
+      const error = new Error("runApi failed");
+      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
+      await (0, _vitest.expect)((0, _authSession._runCheck)({
+        auth: "session",
+        headless: "headless",
+        timeout: 999999999
+      })).rejects.toThrow(error);
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult);
+      await (0, _vitest.expect)((0, _authSession._runCheck)({
+        auth: "session",
+        headless: "headless",
+        timeout: 999999999
+      })).rejects.toThrow("failed");
+    });
+  });
+  (0, _vitest.describe)("runCheckWithRetries", () => {
+    (0, _vitest.it)("retries the check if it fails", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult).mockResolvedValueOnce(_checkPassedResult);
+      const result = await (0, _authSession._runCheckWithRetries)({
+        auth: "session",
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(result).toEqual(true);
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
+    });
+    (0, _vitest.it)("returns false if all retries fail", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.ok)({
+        result: false
+      }));
+      const result = await (0, _authSession._runCheckWithRetries)({
+        auth: "session",
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(result).toEqual(false);
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(10);
+    });
+    (0, _vitest.it)("continues retrying if check fails due to an automation error", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult).mockResolvedValueOnce(_checkPassedResult);
+      const result = await (0, _authSession._runCheckWithRetries)({
+        auth: "session",
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(result).toEqual(true);
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
+    });
+    (0, _vitest.it)("throws the error if check fails with a non-automation error", async () => {
+      const error = new Error("runCheck failed");
+      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
+      await (0, _vitest.expect)((0, _authSession._runCheckWithRetries)({
+        auth: "session",
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      })).rejects.toThrow(error);
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
+    });
+  });
+  (0, _vitest.describe)("runCreate", () => {
+    (0, _vitest.it)("calls timeout middleware with timeout", async () => {
+      await (0, _authSession._runCreate)({
+        authSessionInput: {},
+        headless: false,
+        timeout: 6000
+      });
+      (0, _vitest.expect)(_helpers.withTimeout).toHaveBeenCalledWith(_vitest.expect.any(Function), 6000);
+    });
+    (0, _vitest.it)("calls runApi with correct parameters and parses proxy", async () => {
+      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
+      await (0, _authSession._runCreate)({
+        authSessionInput: "authSessionInput",
+        headless: "headless",
+        timeout: 999999999,
+        proxy: "proxy"
+      });
+      (0, _vitest.expect)(_helpers.parseUrlProxy).toHaveBeenCalledWith("proxy");
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        automationFunction: {
+          name: "auth-sessions/create",
+          params: "authSessionInput"
+        },
+        runOptions: {
+          headless: "headless",
+          environment: "standalone",
+          proxy: "parsed-proxy"
+        },
+        retrieveSession: true
+      }));
+    });
+    (0, _vitest.it)("returns if create returns", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
+      const storageState = await (0, _authSession._runCreate)({
+        authSessionInput: {},
+        headless: "headless",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(storageState).toEqual("session");
+    });
+    (0, _vitest.it)("throws the error create fails with an error", async () => {
+      const error = new Error("runApi failed");
+      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
+      await (0, _vitest.expect)((0, _authSession._runCreate)({
+        authSessionInput: {},
+        headless: "headless",
+        timeout: 999999999
+      })).rejects.toThrow(error);
+    });
+  });
+  (0, _vitest.describe)("runCreateWithRetries", () => {
+    (0, _vitest.it)("saves the auth session instance", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
+      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
+      await (0, _authSession._runCreateWithRetries)({
+        authSessionId: "authSessionId",
+        authSessionInput: "authSessionInput",
+        retries: 10,
+        headless: "headless",
+        proxy: "proxy",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith({
+        state: "session",
+        id: "authSessionId",
+        input: "authSessionInput",
+        proxy: "proxy"
+      });
+    });
+    (0, _vitest.it)("retries the create if it fails with automation error", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult).mockResolvedValueOnce(_createSuccessResult("session"));
+      await (0, _authSession._runCreateWithRetries)({
+        authSessionId: "authSessionId",
+        authSessionInput: "authSessionInput",
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      });
+    });
+    (0, _vitest.it)("throws if all retries fail", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue(_errorResult);
+      await (0, _vitest.expect)((0, _authSession._runCreateWithRetries)({
+        authSessionId: "authSessionId",
+        authSessionInput: {},
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      })).rejects.toThrow(_helpers.CLIError);
+    });
+    (0, _vitest.it)("continues retrying if create fails due to an automation error", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult).mockResolvedValueOnce(_createSuccessResult("session"));
+      const result = await (0, _authSession._runCreateWithRetries)({
+        authSessionId: "authSessionId",
+        authSessionInput: {},
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(result).toEqual("session");
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
+    });
+    (0, _vitest.it)("throws the error if create fails with a non-automation error", async () => {
+      const error = new Error("runCheck failed");
+      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
+      await (0, _vitest.expect)((0, _authSession._runCreateWithRetries)({
+        authSessionId: "authSessionId",
+        authSessionInput: {},
+        retries: 10,
+        headless: "headless",
+        timeout: 999999999
+      })).rejects.toThrow(error);
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
+    });
+  });
+  (0, _vitest.describe)("executeRunValidateAuthSessionCLI", () => {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
+        storageState: {},
+        metadata: {
+          authSessionId: "authSessionId",
+          authSessionType: "API",
+          authSessionInput: {},
+          createdAt: "",
+          updatedAt: ""
+        }
+      });
+    });
+    (0, _vitest.it)("asserts check API file exists", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
+      await (0, _authSession.executeRunValidateAuthSessionCLI)({
+        id: "authSessionId",
+        checkRetries: 1,
+        createRetries: 1,
+        autoRecreate: false,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "check");
+    });
+    (0, _vitest.it)("succeeds if check succeeds", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
+      await (0, _authSession.executeRunValidateAuthSessionCLI)({
+        id: "authSessionId",
+        checkRetries: 1,
+        createRetries: 1,
+        autoRecreate: false,
+        headless: false,
+        timeout: 999999999
+      });
+    });
+    (0, _vitest.it)("throws if check fails with auto recreate disabled", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult);
+      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
+        storageState: {},
+        metadata: {
+          authSessionId: "authSessionId",
+          authSessionType: "API",
+          authSessionInput: {},
+          createdAt: "1970-01-01T00:00:00Z",
+          updatedAt: "1970-01-01T00:00:00Z"
+        }
+      });
+      await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
+        id: "authSessionId",
+        checkRetries: 1,
+        createRetries: 1,
+        autoRecreate: false,
+        headless: false,
+        timeout: 999999999
+      })).rejects.toThrow(_helpers.CLIError);
+    });
+    (0, _vitest.describe)("check failed with auto recreate enabled", () => {
+      (0, _vitest.beforeEach)(() => {
+        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult);
+      });
+      afterEach(() => {
+        _vitest.vi.mocked(_runApi.runApi).mockReset();
+        _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockReset();
+      });
+      (0, _vitest.it)("asserts create API file exists", async () => {
+        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
+        await (0, _authSession.executeRunValidateAuthSessionCLI)({
+          id: "authSessionId",
+          checkRetries: 1,
+          createRetries: 1,
+          autoRecreate: true,
+          headless: false,
+          timeout: 999999999
+        });
+        (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "create");
+      });
+      (0, _vitest.it)("throws if auth session is manual", async () => {
+        _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
+          storageState: {},
+          metadata: {
+            authSessionId: "authSessionId",
+            authSessionType: "MANUAL",
+            authSessionInput: {},
+            createdAt: "",
+            updatedAt: ""
+          }
+        });
+        await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
+          id: "authSessionId",
+          checkRetries: 1,
+          createRetries: 1,
+          autoRecreate: true,
+          headless: false,
+          timeout: 999999999
+        })).rejects.toThrow(_helpers.CLIError);
+      });
+      (0, _vitest.it)("throws if create fails", async () => {
+        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult);
+        await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
+          id: "authSessionId",
+          checkRetries: 1,
+          createRetries: 1,
+          autoRecreate: true,
+          headless: false,
+          timeout: 999999999
+        })).rejects.toThrow(_helpers.CLIError);
+      });
+      (0, _vitest.it)("throws if create succeeds then check fails", async () => {
+        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkFailedResult);
+        await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
+          id: "authSessionId",
+          checkRetries: 1,
+          createRetries: 1,
+          autoRecreate: true,
+          headless: false,
+          timeout: 999999999
+        })).rejects.toThrow(_helpers.CLIError);
+      });
+      (0, _vitest.it)("succeeds if create succeeds then check succeeds", async () => {
+        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
+        await (0, _authSession.executeRunValidateAuthSessionCLI)({
+          id: "authSessionId",
+          checkRetries: 1,
+          createRetries: 1,
+          autoRecreate: true,
+          headless: false,
+          timeout: 999999999
+        });
+      });
+    });
+  });
+  (0, _vitest.describe)("executeRunCreateAuthSessionCLI", () => {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
+    });
+    (0, _vitest.it)("asserts create check API file exists", async () => {
+      await (0, _authSession.executeRunCreateAuthSessionCLI)({
+        input: {},
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "check");
+      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "create");
+    });
+    (0, _vitest.it)("throws if create fails", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_errorResult);
+      await (0, _vitest.expect)((0, _authSession.executeRunCreateAuthSessionCLI)({
+        input: {},
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      })).rejects.toThrow(_helpers.CLIError);
+    });
+    (0, _vitest.it)("throws if check fails after create succeeds", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkFailedResult);
+      await (0, _vitest.expect)((0, _authSession.executeRunCreateAuthSessionCLI)({
+        input: {},
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      })).rejects.toThrow(_helpers.CLIError);
+    });
+    (0, _vitest.it)("saves to auth session instance path if create and check succeed", async () => {
+      await (0, _authSession.executeRunCreateAuthSessionCLI)({
+        input: "authSessionInput",
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        id: _vitest.expect.any(String)
+      }));
+    });
+    (0, _vitest.it)("uses auth session id to save if provided", async () => {
+      const result = await (0, _authSession.executeRunCreateAuthSessionCLI)({
+        id: "authSessionId",
+        input: "authSessionInput",
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        id: "authSessionId"
+      }));
+    });
+  });
+  (0, _vitest.describe)("executeRunUpdateAuthSessionCLI", () => {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
+      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
+        storageState: {},
+        metadata: {
+          authSessionId: "authSessionId",
+          authSessionType: "API",
+          authSessionInput: {},
+          createdAt: "",
+          updatedAt: ""
+        }
+      });
+    });
+    afterEach(() => {
+      _vitest.vi.mocked(_runApi.runApi).mockReset();
+      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockReset();
+    });
+    (0, _vitest.it)("throws if auth session is manual", async () => {
+      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
+        storageState: {},
+        metadata: {
+          authSessionId: "authSessionId",
+          authSessionType: "MANUAL",
+          authSessionInput: {},
+          createdAt: "",
+          updatedAt: ""
+        }
+      });
+      await (0, _vitest.expect)((0, _authSession.executeRunUpdateAuthSessionCLI)({
+        id: "authSessionId",
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      })).rejects.toThrow(_helpers.CLIError);
+    });
+    (0, _vitest.it)("calls create with existing input if no input provided", async () => {
+      await (0, _authSession.executeRunUpdateAuthSessionCLI)({
+        id: "authSessionId",
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        automationFunction: {
+          name: "auth-sessions/create",
+          params: {}
+        },
+        runOptions: {
+          headless: false,
+          environment: "standalone",
+          proxy: undefined
+        },
+        retrieveSession: true
+      }));
+    });
+    (0, _vitest.it)("calls create with new input if provided", async () => {
+      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("newProxy");
+      await (0, _authSession.executeRunUpdateAuthSessionCLI)({
+        id: "authSessionId",
+        input: "newAuthSessionInput",
+        proxy: "newProxyUrl",
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        automationFunction: {
+          name: "auth-sessions/create",
+          params: "newAuthSessionInput"
+        },
+        runOptions: {
+          headless: false,
+          environment: "standalone",
+          proxy: "newProxy"
+        },
+        retrieveSession: true
+      }));
+    });
+    (0, _vitest.it)("saves the auth session with existing input if create and check succeed without providing input", async () => {
+      const result = await (0, _authSession.executeRunUpdateAuthSessionCLI)({
+        id: "authSessionId",
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        id: "authSessionId",
+        input: {},
+        proxy: undefined
+      }));
+    });
+    (0, _vitest.it)("saves the auth session with new input if create and check succeed with new input", async () => {
+      const result = await (0, _authSession.executeRunUpdateAuthSessionCLI)({
+        id: "authSessionId",
+        input: "newAuthSessionInput",
+        proxy: "newProxyUrl",
+        checkRetries: 1,
+        createRetries: 1,
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        id: "authSessionId",
+        input: "newAuthSessionInput",
+        proxy: "newProxyUrl"
+      }));
+    });
+  });
+  (0, _vitest.describe)("executeAttemptCheckAuthSessionCLI", () => {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
+        storageState: {},
+        metadata: {
+          authSessionId: "authSessionId",
+          authSessionType: "API",
+          authSessionInput: {},
+          createdAt: "",
+          updatedAt: ""
+        }
+      });
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
+    });
+    afterEach(() => {
+      _vitest.vi.mocked(_runApi.runApi).mockReset();
+      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockReset();
+    });
+    (0, _vitest.it)("asserts check API file exists", async () => {
+      await (0, _authSession.executeAttemptCheckAuthSessionCLI)({
+        id: "authSessionId",
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "check");
+    });
+    (0, _vitest.it)("succeeds if check succeeds", async () => {
+      await (0, _authSession.executeAttemptCheckAuthSessionCLI)({
+        id: "authSessionId",
+        headless: false,
+        timeout: 999999999
+      });
+    });
+    (0, _vitest.it)("throws if check fails", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_checkFailedResult);
+      await (0, _vitest.expect)((0, _authSession.executeAttemptCheckAuthSessionCLI)({
+        id: "authSessionId",
+        headless: false,
+        timeout: 999999999
+      })).rejects.toThrow(_helpers.CLIError);
+    });
+  });
+  (0, _vitest.describe)("executeAttemptCreateAuthSessionCLI", () => {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
+    });
+    (0, _vitest.it)("asserts create API file exists", async () => {
+      await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
+        input: {},
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "create");
+    });
+    (0, _vitest.it)("throws if create fails", async () => {
+      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_errorResult);
+      await (0, _vitest.expect)((0, _authSession.executeAttemptCreateAuthSessionCLI)({
+        input: {},
+        headless: false,
+        timeout: 999999999
+      })).rejects.toThrow(_helpers.CLIError);
+    });
+    (0, _vitest.it)("saves to auth session instance path if create and check succeed", async () => {
+      await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
+        input: "authSessionInput",
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        id: _vitest.expect.any(String)
+      }));
+    });
+    (0, _vitest.it)("uses auth session id to save if provided", async () => {
+      await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
+        id: "authSessionId",
+        input: "authSessionInput",
+        headless: false,
+        timeout: 999999999
+      });
+      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
+        id: "authSessionId"
+      }));
+    });
+  });
+});