@intuned/runtime-dev 1.2.0-cli.5 → 1.2.0-cli.7

package/dist/commands/api/run.js

@@ -18,6 +18,7 @@ var _chalk = _interopRequireDefault(require("chalk"));
 var _runApi = require("../../common/runApi");
 var _tsNodeImport = require("../common/tsNodeImport");
 var _isNil = _interopRequireDefault(require("lodash/isNil"));
+var _constants = require("../../common/constants");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -40,7 +41,7 @@ async function executeCLI(apiName, mode, inputData, options) {
   }
   const runApiResult = await (0, _runApi.runApi)({
     automationFunction: {
-      name: `api/${apiName}`,
+      name: `${_constants.API_FOLDER_NAME}/${apiName}`,
       params: inputData
     },
     auth: authSessionPathToUse ? {

package/dist/commands/intuned-cli/commands/run_authsession.command.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="ms" />
 export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodObject<{
     proxy: import("zod").ZodOptional<import("zod").ZodString>;
     headless: import("zod").ZodDefault<import("zod").ZodBoolean>;

package/dist/commands/intuned-cli/constants/index.d.ts

@@ -10,15 +10,12 @@ export declare const userCLIScripts: {
     "pre-publish": string;
     start: string;
     "run-api": string;
-    "cli-build": string;
-    deploy: string;
-    "cli-create-auth-session": string;
-    "cli-check-auth-session": string;
     "browser-save-state": string;
     "auth-session-check": string;
     "auth-session-create": string;
     "auth-session-refresh": string;
     "auth-session-load": string;
+    intuned: string;
 };
 export declare const tsConfigCli: {
     compilerOptions: {

package/dist/commands/intuned-cli/constants/index.js

@@ -38,15 +38,12 @@ const userCLIScripts = exports.userCLIScripts = {
   "pre-publish": "intuned-ts-check && intuned-build",
   start: "node ./output/bundle_v2.js",
   "run-api": "run-api",
-  "cli-build": "cli-build",
-  deploy: "deploy",
-  "cli-create-auth-session": "create-auth-session",
-  "cli-check-auth-session": "check-auth-session",
   "browser-save-state": "intuned-browser-save-state",
   "auth-session-check": "intuned-auth-session-check",
   "auth-session-create": "intuned-auth-session-create",
   "auth-session-refresh": "intuned-auth-session-refresh",
-  "auth-session-load": "intuned-auth-session-load"
+  "auth-session-load": "intuned-auth-session-load",
+  intuned: "intuned"
 };
 const tsConfigCli = exports.tsConfigCli = {
   compilerOptions: {

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

@@ -0,0 +1,280 @@
+"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");
+function getTerminal() {
+  return new Proxy(() => ({}), {
+    get: () => getTerminal(),
+    apply: () => ({})
+  });
+}
+_vitest.vi.mock("fs-extra", () => ({
+  writeJSON: _vitest.vi.fn()
+}));
+_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", 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(),
+    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
+      });
+      (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, _api._attemptApi)({
+        apiName: "testApi",
+        inputData: "inputData",
+        headless: "headless",
+        auth: "auth",
+        proxy: "proxy",
+        timeout: 999999999
+      });
+      (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"
+          },
+          runCheck: false
+        },
+        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
+      });
+      (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
+      })).rejects.toThrow(error);
+    });
+  });
+  (0, _vitest.describe)("executeRunApiCLI", () => {
+    (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({
+        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({
+        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)("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");
+    });
+  });
+});