@intuned/runtime-dev 1.3.8-jsonl.0 → 1.3.9-dev1

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

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