@intuned/runtime-dev 1.3.9-dev9 → 1.3.11-deployment.0

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

@@ -1,397 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _api = require("../api");
-var _authSession = require("../authSession");
-var _helpers = require("../../helpers");
-var _neverthrow = require("neverthrow");
-var _runApi = require("../../../../common/runApi");
-var _fsExtra = require("fs-extra");
-var _browser = require("../../helpers/browser");
-function getTerminal() {
-  return new Proxy(() => ({}), {
-    get: () => getTerminal(),
-    apply: () => ({})
-  });
-}
-_vitest.vi.mock("fs-extra", () => ({
-  writeJSON: _vitest.vi.fn(),
-  exists: _vitest.vi.fn().mockResolvedValue(true)
-}));
-_vitest.vi.mock("../authSession", async importOriginal => {
-  const original = await importOriginal();
-  return {
-    ...original,
-    executeRunValidateAuthSessionCLI: _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/proxy", async () => {
-  return {
-    parseUrlProxy: _vitest.vi.fn()
-  };
-});
-_vitest.vi.mock("../../helpers/browser", async importOriginal => {
-  const original = await importOriginal();
-  return {
-    getCLIRunOptions: _vitest.vi.fn(({
-      keepBrowserOpen: _,
-      ...rest
-    }) => original.getCLIRunOptions({
-      keepBrowserOpen: false,
-      ...rest
-    }))
-  };
-});
-_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()),
-    withCLITrace: _vitest.vi.fn(original.withCLITrace),
-    registerGetAuthSessionParameters: _vitest.vi.fn()
-  };
-});
-(0, _vitest.describe)("API controller", () => {
-  (0, _vitest.beforeEach)(() => {
-    _vitest.vi.clearAllMocks();
-  });
-  (0, _vitest.describe)("attemptApi", () => {
-    (0, _vitest.it)("calls timeout middleware with timeout", async () => {
-      await (0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.withTimeout).toHaveBeenCalledWith(_vitest.expect.any(Function), 6000);
-    });
-    (0, _vitest.it)("uses tracing wrapper with trace id", async () => {
-      await (0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), undefined);
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false,
-        traceId: "trace-id"
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), "trace-id");
-    });
-    (0, _vitest.it)("uses cli browser helper", async () => {
-      await (0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_browser.getCLIRunOptions).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        headless: false,
-        keepBrowserOpen: false
-      }));
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: {},
-        headless: true,
-        timeout: 6000,
-        keepBrowserOpen: true
-      });
-      (0, _vitest.expect)(_browser.getCLIRunOptions).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        headless: true,
-        keepBrowserOpen: true
-      }));
-    });
-    (0, _vitest.it)("calls runApi with correct parameters and parses proxy", async () => {
-      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
-      await (0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: "inputData",
-        headless: "headless",
-        auth: "auth",
-        proxy: "proxy",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.parseUrlProxy).toHaveBeenCalledWith("proxy");
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        automationFunction: {
-          name: "api/testApi",
-          params: "inputData"
-        },
-        runOptions: {
-          headless: "headless",
-          environment: "standalone",
-          proxy: "parsed-proxy"
-        },
-        auth: {
-          session: {
-            type: "state",
-            state: "auth"
-          }
-        },
-        importFunction: _vitest.expect.anything()
-      }));
-    });
-    (0, _vitest.it)("returns the result and extended payloads if runApi succeeds", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce((0, _neverthrow.ok)({
-        result: "result",
-        extendedPayloads: "extendedPayloads"
-      }));
-      const result = await (0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: "inputData",
-        headless: "headless",
-        auth: "auth",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(result).toEqual({
-        result: "result",
-        payloadToAppend: "extendedPayloads"
-      });
-    });
-    (0, _vitest.it)("throws the error runApi fails with an error", async () => {
-      const error = new Error("runApi failed");
-      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
-      await (0, _vitest.expect)((0, _api._attemptApi)({
-        apiName: "testApi",
-        inputData: "inputData",
-        headless: "headless",
-        auth: "auth",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      })).rejects.toThrow(error);
-    });
-  });
-  (0, _vitest.describe)("executeRunApiCLI", () => {
-    (0, _vitest.it)("enables tracing correctly", async () => {
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 1,
-        trace: false
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        tracing: {
-          enabled: false
-        }
-      }));
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 1,
-        trace: true
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        tracing: _vitest.expect.objectContaining({
-          enabled: true
-        })
-      }));
-    });
-    (0, _vitest.it)("calls attemptApi once if success", async () => {
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 3
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
-    });
-    (0, _vitest.it)("stops retrying after max retries", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.err)(new _runApi.AutomationError("runApi failed")));
-      await (0, _vitest.expect)((0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 10
-      })).rejects.toThrow(_helpers.CLIError);
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(10);
-    });
-    (0, _vitest.it)("stops retrying on non-automation errors", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockRejectedValue(new Error("runApi failed"));
-      await (0, _vitest.expect)((0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 3
-      })).rejects.toThrow("runApi failed");
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
-    });
-    (0, _vitest.it)("stops retrying on success", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce((0, _neverthrow.err)(new _runApi.AutomationError("runApi failed"))).mockResolvedValue((0, _neverthrow.ok)({
-        result: "success"
-      }));
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 10
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
-    });
-    (0, _vitest.it)("validates auth session before each attempt if provided", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce((0, _neverthrow.err)(new _runApi.AutomationError("runApi failed"))).mockResolvedValue((0, _neverthrow.ok)({
-        result: "success"
-      }));
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        authSession: {
-          id: "authSessionId",
-          autoRecreate: false,
-          checkRetries: 1,
-          createRetries: 2
-        },
-        retries: 10
-      });
-      (0, _vitest.expect)(_authSession.executeRunValidateAuthSessionCLI).toBeCalledTimes(2);
-      (0, _vitest.expect)(_authSession.executeRunValidateAuthSessionCLI).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: "authSessionId",
-        autoRecreate: false,
-        checkRetries: 1,
-        createRetries: 2
-      }));
-    });
-    (0, _vitest.it)("doesn't validate auth session if not provided", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.ok)({
-        result: "success"
-      }));
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 1
-      });
-      (0, _vitest.expect)(_authSession.executeRunValidateAuthSessionCLI).not.toHaveBeenCalled();
-    });
-    (0, _vitest.it)("fails if auth session is provided but not valid", async () => {
-      _vitest.vi.mocked(_authSession.executeRunValidateAuthSessionCLI).mockRejectedValue(new _helpers.CLIError("Auth session validation failed"));
-      await (0, _vitest.expect)((0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        authSession: {
-          id: "authSessionId",
-          autoRecreate: false,
-          checkRetries: 1,
-          createRetries: 2
-        },
-        retries: 10
-      })).rejects.toThrow("Auth session validation failed");
-      (0, _vitest.expect)(_authSession.executeRunValidateAuthSessionCLI).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: "authSessionId",
-        autoRecreate: false,
-        checkRetries: 1,
-        createRetries: 2
-      }));
-      (0, _vitest.expect)(_runApi.runApi).not.toHaveBeenCalled();
-    });
-    (0, _vitest.it)("writes result to file if outputFile is provided", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.ok)({
-        result: "result",
-        extendedPayloads: "extendedPayloads"
-      }));
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        outputFile: "output.json",
-        retries: 1
-      });
-      (0, _vitest.expect)(_fsExtra.writeJSON).toHaveBeenCalledWith("output.json", {
-        result: "result",
-        extendedPayloads: "extendedPayloads"
-      }, _vitest.expect.anything());
-    });
-    (0, _vitest.it)("asserts API file exists", async () => {
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 1
-      });
-      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("api", "testApi");
-    });
-  });
-  (0, _vitest.describe)("executeAttemptApiCLI", () => {
-    (0, _vitest.it)("enables tracing correctly", async () => {
-      await (0, _api.executeAttemptApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        trace: false
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        tracing: {
-          enabled: false
-        }
-      }));
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _api.executeAttemptApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        trace: true
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        tracing: _vitest.expect.objectContaining({
-          enabled: true
-        })
-      }));
-    });
-    (0, _vitest.it)("calls attemptApi once", async () => {
-      await (0, _api.executeAttemptApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 3
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
-      _vitest.vi.mocked(_runApi.runApi).mockReset();
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.err)(new _runApi.AutomationError("runApi failed")));
-      await (0, _vitest.expect)((0, _api.executeAttemptApiCLI)({
-        apiName: "testApi",
-        inputData: {}
-      })).rejects.toThrow(_runApi.AutomationError);
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
-    });
-    (0, _vitest.it)("writes result to file if outputFile is provided", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.ok)({
-        result: "result",
-        extendedPayloads: "extendedPayloads"
-      }));
-      await (0, _api.executeAttemptApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        outputFile: "output.json"
-      });
-      (0, _vitest.expect)(_fsExtra.writeJSON).toHaveBeenCalledWith("output.json", {
-        result: "result",
-        extendedPayloads: "extendedPayloads"
-      }, _vitest.expect.anything());
-    });
-    (0, _vitest.it)("asserts API file exists", async () => {
-      await (0, _api.executeRunApiCLI)({
-        apiName: "testApi",
-        inputData: {},
-        retries: 1
-      });
-      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("api", "testApi");
-    });
-  });
-});