@playq/core 0.2.77

package/dist/helper/actions/api/apiRequestActions.js

@@ -0,0 +1,374 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callApi = callApi;
+exports.get = get;
+exports.post = post;
+exports.request = request;
+exports.put = put;
+exports.patch = patch;
+exports.del = del;
+exports.sendRequest = sendRequest;
+/**
+ * @file apiRequestActions.ts
+ *
+ * Provides a unified API for API actions in Playwright and Cucumber frameworks.
+ * Supports dynamic config-driven requests, variable interpolation, and assertions.
+ *
+ * Key Features:
+ * - Hybrid context support: Playwright runner and Cucumber world.
+ * - Rich options for redirects, timeouts, auth, and type conversions.
+ * - Robust error handling and logging aligned with PlayQ standards.
+ *
+ * Authors: Renish Kozhithottathil [Lead Automation Principal, NCS]
+ * Date: 2025-07-01
+ * Version: v1.0.0
+ *
+ * Note: This file adheres to the PlayQ Enterprise Automation Standards.
+ */
+const axios_1 = __importDefault(require("axios"));
+const allure = __importStar(require("allure-js-commons"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const global_1 = require("../../../global");
+const test_1 = require("@playwright/test");
+// Inline runner helpers
+function isPlaywrightRunner() { return process.env.TEST_RUNNER === 'playwright'; }
+function isCucumberRunner() { return process.env.TEST_RUNNER === 'cucumber'; }
+const __allureAny_api = allure;
+if (typeof __allureAny_api.step !== 'function') {
+    __allureAny_api.step = async (_name, fn) => await fn();
+}
+/**
+ * Api: Call api -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Calls a predefined API action using configuration from a resource file, supporting dynamic variable replacement,
+ * custom headers, body, parameters, authentication, and assertion of expected status codes.
+ *
+ * This function is designed for hybrid Playwright/Cucumber test frameworks, enabling enterprise-grade API testing
+ * with robust error handling and flexible options.
+ *
+ * @param action - The API action name (corresponds to a file in `resources/api/{action}.api.ts`).
+ * @param config - The configuration key within the API module (e.g., "success", "errorCase").
+ * @param baseUrl - The base URL for the API endpoint.
+ * @param options - Optional. Additional options as a JSON string or object. Supports:
+ *   - `maxUrlRedirects`: Maximum number of redirects (default: from config or 5).
+ *   - `maxTimeout`: Request timeout in milliseconds (default: from config or 10000).
+ *   - `auth`: Axios authentication object.
+ *   - Any other Axios request config options.
+ *
+ * @throws Error if the API config is not found or if the response status does not match `expectedStatus` in config.
+ *
+ * @example
+ * // Example API config file: resources/api/user.api.ts
+ * export const api = {
+ *   getUser: {
+ *     path: "/users/{userId}",
+ *     method: "GET",
+ *     headers: { "Authorization": "Bearer ${token}" },
+ *     expectedStatus: "200"
+ *   }
+ * };
+ *
+ * // Usage in test:
+ * await callApi(
+ *   "user",
+ *   "getUser",
+ *   "https://api.example.com",
+ *   { userId: "123", token: "abc123" }
+ * );
+ *
+ * @example
+ * // With options as a JSON string:
+ * await callApi(
+ *   "user",
+ *   "getUser",
+ *   "https://api.example.com",
+ *   '{"userId":"123","token":"abc123","maxTimeout":5000}'
+ * );
+ *
+ * @example
+ * // With custom authentication:
+ * await callApi(
+ *   "user",
+ *   "getUser",
+ *   "https://api.example.com",
+ *   { auth: { username: "admin", password: "secret" } }
+ * );
+ */
+async function callApi(action, config, baseUrl, options) {
+    const options_json = typeof options === "string" ? global_1.vars.parseLooseJson(options) : options || {};
+    const { maxUrlRedirects = Number(global_1.vars.getConfigValue("apiTest.maxUrlRedirects")) || 5, // Axios defalt is 5
+    maxTimeout = Number(global_1.vars.getConfigValue("apiTest.timeout")) || 10000, auth, toNumber = undefined, toBoolean = undefined, } = options_json !== null && options_json !== void 0 ? options_json : {};
+    // Input validation
+    if (!action || typeof action !== 'string') {
+        throw new Error("Action must be a non-empty string.");
+    }
+    if (!config || typeof config !== 'string') {
+        throw new Error("Config must be a non-empty string.");
+    }
+    if (!baseUrl || typeof baseUrl !== 'string') {
+        throw new Error("Base URL must be a non-empty string.");
+    }
+    const stepName = `Api: Call api -action: ${action} -config: ${config} -baseUrl: ${baseUrl} -options: ${JSON.stringify(options_json)}`;
+    if (isPlaywrightRunner()) {
+        await test_1.test.step(stepName, async () => {
+            await doCallApi();
+        });
+    }
+    else {
+        await doCallApi();
+    }
+    async function doCallApi() {
+        var _a, _b;
+        // Dynamic import of the module
+        global_1.vars.setValue("internal.api.last.resStatus", "");
+        global_1.vars.setValue("internal.api.last.resStatusText", "");
+        global_1.vars.setValue("internal.api.last.resHeader", "");
+        global_1.vars.setValue("internal.api.last.resBody", "");
+        const projectRoot = process.env.PLAYQ_PROJECT_ROOT || process.cwd();
+        const candidateTs = path_1.default.resolve(projectRoot, 'resources', 'api', `${action}.api.ts`);
+        const candidateJs = path_1.default.resolve(projectRoot, 'resources', 'api', `${action}.api.js`);
+        let actionPath;
+        if (fs_1.default.existsSync(candidateTs)) {
+            actionPath = candidateTs;
+        }
+        else if (fs_1.default.existsSync(candidateJs)) {
+            actionPath = candidateJs;
+        }
+        else {
+            throw new Error(`API config file not found for action '${action}'. Looked for: ${candidateTs} and ${candidateJs}`);
+        }
+        // const actionPath = require.resolve(`../../../resources/api/${action}.api.ts`);
+        const apiModule = await require(actionPath);
+        const apiConfig = apiModule.api[config];
+        if (!apiConfig) {
+            throw new Error(`Config '${config}' not found in ${actionPath}`);
+        }
+        const reqUrl = global_1.vars.replaceVariables(`${baseUrl}${(_a = apiConfig.path) !== null && _a !== void 0 ? _a : ""}`);
+        const reqMethod = global_1.vars.replaceVariables((_b = apiConfig.method) !== null && _b !== void 0 ? _b : "");
+        if (!reqMethod || typeof reqMethod !== 'string') {
+            throw new Error(`API config '${config}' must specify a valid 'method'.`);
+        }
+        const reqHeaders = apiConfig.headers
+            ? JSON.parse(global_1.vars.replaceVariables(JSON.stringify(apiConfig.headers)))
+            : {};
+        const reqBody = apiConfig.body
+            ? JSON.parse(global_1.vars.replaceVariables(JSON.stringify(apiConfig.body)))
+            : undefined;
+        const reqParams = apiConfig.params
+            ? JSON.parse(global_1.vars.replaceVariables(JSON.stringify(apiConfig.params)))
+            : undefined;
+        if (reqBody && toNumber)
+            convertJsonNodes(reqBody, "toNumber", toNumber);
+        if (reqBody && toBoolean)
+            convertJsonNodes(reqBody, "toBoolean", toBoolean);
+        // Attach request details for traceability
+        try {
+            const reqInfo = {
+                method: reqMethod,
+                url: reqUrl,
+                headers: reqHeaders,
+                params: reqParams,
+                body: reqBody
+            };
+            await global_1.comm.attachLog(`API Request: ${JSON.stringify(reqInfo)}`, "application/json", "API Request");
+        }
+        catch { }
+        let response;
+        if (reqMethod.toUpperCase().trim() == 'GET') {
+            response = await (0, axios_1.default)({
+                method: reqMethod,
+                url: reqUrl,
+                headers: reqHeaders,
+                params: reqParams,
+                maxRedirects: maxUrlRedirects,
+                timeout: maxTimeout,
+                validateStatus: () => true,
+                auth
+            });
+        }
+        else {
+            response = await (0, axios_1.default)({
+                method: reqMethod,
+                url: reqUrl,
+                headers: reqHeaders,
+                data: reqBody,
+                maxRedirects: maxUrlRedirects,
+                timeout: maxTimeout,
+                validateStatus: () => true,
+                auth
+            });
+        }
+        const resStatus = (await response).status.toString();
+        const resStatusText = (await response).statusText;
+        const resHeader = JSON.stringify((await response).headers);
+        const resBody = JSON.stringify((await response).data);
+        global_1.vars.setValue("playq.api.last.resStatus", resStatus);
+        global_1.vars.setValue("playq.api.last.resStatusText", resStatusText);
+        global_1.vars.setValue("playq.api.last.resHeader", resHeader);
+        global_1.vars.setValue("playq.api.last.resBody", resBody);
+        // This console is to show the api response.
+        console.log("API Response:", {
+            status: resStatus,
+            statusText: resStatusText,
+            headers: resHeader,
+            body: resBody
+        });
+        // Attach response details
+        try {
+            await global_1.comm.attachLog(`API Response: ${JSON.stringify({ status: resStatus, statusText: resStatusText })}`, "text/plain", "API Response");
+            // Attach compact body header snapshots to avoid huge logs
+            await global_1.comm.attachLog(resHeader, "application/json", "API Response Headers");
+            await global_1.comm.attachLog(resBody, "application/json", "API Response Body");
+        }
+        catch { }
+        if (apiConfig.expectedStatus) {
+            if (apiConfig.expectedStatus != resStatus) {
+                await global_1.comm.attachLog(`❌ Status mismatch for '${config}' Expected: '${apiConfig.expectedStatus}' Actual: '${resStatus}'`, "text/plain", "API Verification");
+                throw new Error(`Api Response for '${config}' Expected: '${apiConfig.expectedStatus}' Actual: '${resStatus}'`);
+            }
+            else {
+                await global_1.comm.attachLog(`✅ Status matched for '${config}': '${resStatus}'`, "text/plain", "API Verification");
+            }
+        }
+    }
+}
+/**
+ * Converts specific JSON node values within an object based on provided keys.
+ * Supports nested keys using dot notation, e.g., "payment.arreasFlag".
+ *
+ * @param obj - The JSON object to mutate (in-place). If undefined, no-op.
+ * @param type - Conversion type: "toNumber" or "toBoolean".
+ * @param keys - Comma-separated list of keys to convert.
+ */
+function convertJsonNodes(obj, type, keys) {
+    if (!obj || !keys || typeof keys !== 'string')
+        return;
+    const keyList = keys.split(',').map(k => k.trim());
+    for (const key of keyList) {
+        // Support nested keys like "payment.arreasFlag"
+        const path = key.split('.');
+        let ref = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+            if (ref[path[i]] === undefined)
+                break;
+            ref = ref[path[i]];
+        }
+        const lastKey = path[path.length - 1];
+        if (ref && ref[lastKey] !== undefined) {
+            if (type === "toNumber")
+                ref[lastKey] = Number(ref[lastKey]);
+            if (type === "toBoolean")
+                ref[lastKey] = ref[lastKey] === "true" || ref[lastKey] === true;
+        }
+    }
+}
+/**
+ * Api: Get -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends a GET-style request using an API config. Alias of `callApi`.
+ *
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to `callApi`.
+ */
+async function get(action, config, baseUrl, options) {
+    return callApi(action, config, baseUrl, options);
+}
+/**
+ * Api: Post -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends a POST-style request using an API config. Alias of `callApi`.
+ *
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to `callApi`.
+ */
+async function post(action, config, baseUrl, options) {
+    return callApi(action, config, baseUrl, options);
+}
+/**
+ * Api: Request -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends a request (generic wrapper). Alias of `callApi`.
+ *
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to `callApi`.
+ */
+async function request(action, config, baseUrl, options) {
+    return callApi(action, config, baseUrl, options);
+}
+/**
+ * Api: Put -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ * Sends a PUT-style request using an API config. Alias of callApi.
+ */
+async function put(action, config, baseUrl, options) {
+    return callApi(action, config, baseUrl, { ...(typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {}), method: 'PUT' });
+}
+/**
+ * Api: Patch -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ * Sends a PATCH-style request using an API config. Alias of callApi.
+ */
+async function patch(action, config, baseUrl, options) {
+    return callApi(action, config, baseUrl, { ...(typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {}), method: 'PATCH' });
+}
+/**
+ * Api: Delete -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ * Sends a DELETE-style request using an API config. Alias of callApi.
+ */
+async function del(action, config, baseUrl, options) {
+    return callApi(action, config, baseUrl, { ...(typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {}), method: 'DELETE' });
+}
+/**
+ * Api: Send request -method: {param} -action: {param} -config: {param} -baseUrl: {param} -options: {param}
+ *
+ * Sends an HTTP request using the specified method and API config.
+ * @param method - HTTP method (GET, POST, PUT, PATCH, DELETE, etc.)
+ * @param action - API action name.
+ * @param config - Config key within the action module.
+ * @param baseUrl - Base URL for the request.
+ * @param options - Additional options forwarded to callApi.
+ */
+async function sendRequest(method, action, config, baseUrl, options) {
+    return callApi(action, config, baseUrl, { ...(typeof options === 'string' ? global_1.vars.parseLooseJson(options) : options || {}), method });
+}

package/dist/helper/actions/api/apiValidationActions.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Api: Verify value -actual: {param} -expected: {param} -options: {param}
+ *
+ * Verifies that a given value matches the expected value.
+ * Throws an error if the values do not match.
+ *
+ * @param actual - The actual value to verify.
+ * @param expected - The expected value to compare against.
+ * @param message - Optional. Custom error message on failure.
+ */
+export declare function verifyValue(actual: any, expected: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Verify api path value in last response -path: {param} -expected: {param} -options: {param}
+ *
+ * Verifies that a value at a given JSON path in the last API response matches the expected value.
+ * Throws an error if the values do not match.
+ *
+ * @param path - The JSON path to extract from the last response body/header/status.
+ * @param expected - The expected value to compare against.
+ * @param options - Optional. Supports { assert: boolean, partial_text: boolean }
+ */
+export declare function verifyPathValue(path: string, expected: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Get last response JSON path value -path: {param} -storeTo: {param}
+ *
+ * Get the value at a given JSON path from the last API response body.
+ * Example: path = "data[0].id" will return the id of the first item in data array.
+ * Supports paths like "x.data[0].id" (where "x" is treated as the root).
+ *
+ * @param path - JSON path string; supports leading "x." as body alias.
+ * @returns The extracted value or undefined if not found.
+ * @throws Error if `path` is not a non-empty string.
+
+ */
+export declare function getLastResponseJsonPathValue(path: string): Promise<any>;
+/**
+ * Api: Store last response JSON paths to variables -paths: {param} -vars: {param}
+ *
+ * Assign multiple values from the last API response body, header, status, or status text to variables.
+ * @param pathVarString Comma-separated JSON paths (e.g. "x.data[1].email,h.content-type,s.,t.")
+ * @param varKeyString  Comma-separated variable keys (e.g. "var.email,var.contentType,var.status,var.statusText")
+ * Prefixes (case-insensitive):
+ *   x. / (body). = response body (default if no prefix)
+ *   h. / (header). = response header
+ *   s / (status) / (statusCode) = response status code
+ *   t / (statusText) = response status text
+ * Examples:
+ *   "x.data[0].id" or "(body).data[0].id" → from body
+ *   "h.content-type" or "(header).content-type" → from header
+ *   "s" or "(status)" or "(statusCode)" → response status code
+ *   "t" or "(statusText)" → response status text
+ *   "data[0].id" → from body (default)
+ *
+ * @throws Error if inputs are missing or the number of paths and variable keys differ.
+ */
+export declare function storeLastResponseJsonPathsToVariables(pathVarString: string, varKeyString: string): Promise<void>;
+/**
+ * Api: Get path value from last response -path: {param} -storeTo: {param}
+ *
+ * Get a value from the last API response using a flexible path.
+ * Supports body, header, status, and statusText via prefixes:
+ *  - Body: default or `x.` or `(body).`
+ *  - Header: `h.` or `(header).`
+ *  - Status code: `s` or `(status)` or `(statusCode)`
+ *  - Status text: `t` or `(statusText)`
+ *
+ * @param path - Path string (e.g., `title`, `x.data[0].id`, `h.content-type`, `s`, `t`)
+ * @param options - Optional JSON string or object (reserved)
+ * @returns Extracted value or undefined
+ * @throws Error if `path` is not a non-empty string
+ */
+export declare function getPathValueFromLastResponse(path: string, options?: string | Record<string, any>): Promise<any>;
+export declare const assertValue: typeof verifyValue;
+export declare const assertPathValue: typeof verifyPathValue;
+export declare const storePaths: typeof storeLastResponseJsonPathsToVariables;
+/**
+ * Api: Extract the entire root-level array from the last API response body.
+ * @returns {any[]} The parsed array, or throws if not an array.
+ */
+export declare function getLastResponseArray(): Promise<any[]>;
+/**
+ * Api: Extract a property from each object in the root-level array from the last API response body.
+ * @param {string} property - The property name to extract from each object.
+ * @returns {any[]} Array of property values.
+ */
+export declare function getPropertyFromLastResponseArray(property: string): Promise<any[]>;
+/**
+ * Api: Generic extractor for last response body (array, object, or primitive).
+ * If a path is provided, will attempt to extract using dot/bracket notation.
+ * If no path is provided, returns the parsed body (array/object/primitive).
+ * @param {string} [path] - Optional dot/bracket path (e.g., 'data[0].id').
+ * @returns {any} Extracted value or the parsed body.
+ */
+export declare function extractFromLastResponse(path?: string): Promise<any>;
+/**
+ * Api: Assert last response status code.
+ * @param expectedStatus - Expected HTTP status code (string or number).
+ * @param options - Optional: { assert: boolean }
+ */
+export declare function verifyStatus(expectedStatus: string | number, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Assert last response header value.
+ * @param header - Header name (case-insensitive).
+ * @param expectedValue - Expected value (string).
+ * @param options - Optional: { assert: boolean, partial_text: boolean }
+ */
+export declare function verifyHeader(header: string, expectedValue: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Assert last response body matches JSON schema.
+ * @param schema - JSON schema object.
+ * @param options - Optional: { assert: boolean }
+ */
+export declare function verifySchema(schema: object, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Api: Assert last response is error/timeout (negative test).
+ * @param expectedStatus - Expected error status code (string or number).
+ * @param options - Optional: { assert: boolean }
+ */
+export declare function verifyError(expectedStatus: string | number, options?: string | Record<string, any>): Promise<void>;