@playq/core 0.2.77

package/dist/helper/actions/apiStepDefs.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cucumber_1 = require("@cucumber/cucumber");
+const global_1 = require("../../global");
+/**
+ * API Step Definitions
+ *
+ * Cucumber step patterns for API request and validation actions.
+ * Mirrors the functions in apiRequestActions.ts and apiValidationActions.ts.
+ */
+(0, cucumber_1.Given)("Api: Call api -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action, config, baseUrl, options) {
+    await global_1.api.callApi(action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Get -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action, config, baseUrl, options) {
+    await global_1.api.get(action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Post -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action, config, baseUrl, options) {
+    await global_1.api.post(action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Request -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action, config, baseUrl, options) {
+    await global_1.api.request(action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Put -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action, config, baseUrl, options) {
+    await global_1.api.put(action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Patch -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action, config, baseUrl, options) {
+    await global_1.api.patch(action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Delete -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (action, config, baseUrl, options) {
+    await global_1.api.del(action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Send request -method: {param} -action: {param} -config: {param} -baseUrl: {param} -options: {param}", async function (method, action, config, baseUrl, options) {
+    await global_1.api.sendRequest(method, action, config, baseUrl, options);
+});
+(0, cucumber_1.Given)("Api: Verify value -actual: {param} -expected: {param} -options: {param}", async function (actual, expected, options) {
+    await global_1.api.verifyValue(actual, expected, options);
+});
+(0, cucumber_1.Given)("Api: Assert value -actual: {param} -expected: {param} -options: {param}", async function (actual, expected, options) {
+    await global_1.api.assertValue(actual, expected, options);
+});
+(0, cucumber_1.Given)("Api: Verify api path value in last response -path: {param} -expected: {param} -options: {param}", async function (path, expected, options) {
+    await global_1.api.verifyPathValue(path, expected, options);
+});
+(0, cucumber_1.Given)("Api: Assert api path value -path: {param} -expected: {param} -options: {param}", async function (path, expected, options) {
+    await global_1.api.assertPathValue(path, expected, options);
+});
+(0, cucumber_1.Given)("Api: Get last response JSON path value -path: {param} -storeTo: {param}", async function (pathExpr, varName) {
+    const value = await global_1.api.getLastResponseJsonPathValue(pathExpr);
+    if (value !== undefined && value !== null) {
+        global_1.vars.setValue(varName, String(value));
+    }
+});
+(0, cucumber_1.Given)("Api: Store last response JSON paths to variables -paths: {param} -vars: {param}", async function (paths, varsCsv) {
+    await global_1.api.storeLastResponseJsonPathsToVariables(paths, varsCsv);
+});
+(0, cucumber_1.Given)("Api: Get path value from last response -path: {param} -storeTo: {param}", async function (pathExpr, varName) {
+    const value = await global_1.api.getPathValueFromLastResponse(pathExpr);
+    if (value !== undefined && value !== null) {
+        global_1.vars.setValue(varName, String(value));
+    }
+});
+(0, cucumber_1.Given)("Api: Store paths -paths: {param} -vars: {param}", async function (paths, varsCsv) {
+    await global_1.api.storePaths(paths, varsCsv);
+});

package/dist/helper/actions/comm/commonActions.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Comm: Comment -text: {param}
+ *
+ * Logs a comment with variable substitution to the console.
+ * Useful for adding contextual information to the test log.
+ *
+ * Variables inside the message string (e.g., ${var.username}) will be replaced using `vars.replaceVariables`.
+ *
+ * @param message - The comment or message to log.
+ *
+ * @throws Error if `message` is not a non-empty string.
+ *
+ * @example
+ * Comm: Comment -text: "LAMBDA TEST COMPLETE"
+ */
+export declare function comment(message: string): Promise<void>;
+/**
+ * Comm: Store -value: {param} in -variable: {param} -options: {param}
+ *
+ * Stores a value (with optional variable substitution) into a runtime variable.
+ *
+ * Variables inside the value string (e.g., ${var.username}) will be resolved using `vars.replaceVariables`.
+ *
+ * @param value - The value to store (can include variable references).
+ * @param varName - The name of the variable to store the resolved value into.
+ * @param options - Optional string or object with additional parameters (parsed if string). Currently unused but reserved for future logic.
+ *
+ * @throws Error if `varName` is not a non-empty string or `value` is undefined/null.
+ *
+ * @example
+ * Store -value: "${faker.string.alphanumeric({length:4})}" in -variable: "var.centre.code" -options: ""
+ */
+export declare function storeValue(value: string, varName: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Comm: Attach-Log -message: {param} -mimeType: {param} -msgType: {param}
+ *
+ * Attach log or message to the test context (Cucumber or Playwright runner).
+ * @param message The message or buffer to attach
+ * @param mimeType The mime type (default: text/plain)
+ * @param msgType Optional label for the attachment (default: "Log").
+ *
+ * If `message` is empty or undefined, a warning is logged and no attachment is made.
+ */
+export declare function attachLog(message: string | Buffer, mimeType?: string, msgType?: string): Promise<void>;
+/**
+ * Comm: Wait-In-Milli-Seconds -seconds: {param}
+ *
+ * Pauses execution for a given number of milliseconds.
+ * Logs a message using the test logger if available.
+ *
+ * @param ms - The number of milliseconds to wait.
+ *
+ * @throws Error if `ms` is not a finite number or is negative.
+ *
+ * @example
+ * Comm: Wait-In-Milli-Seconds -seconds: "1000"
+ */
+export declare function waitInMilliSeconds(ms: number): Promise<void>;

package/dist/helper/actions/comm/commonActions.js

@@ -0,0 +1,198 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comment = comment;
+exports.storeValue = storeValue;
+exports.attachLog = attachLog;
+exports.waitInMilliSeconds = waitInMilliSeconds;
+const global_1 = require("../../../global");
+const vars_1 = require("../../bundle/vars");
+const allure = __importStar(require("allure-js-commons"));
+function isPlaywrightRunner() { return process.env.TEST_RUNNER === 'playwright'; }
+function isCucumberRunner() { return process.env.TEST_RUNNER === 'cucumber'; }
+const __allureAny_comm = allure;
+if (typeof __allureAny_comm.step !== 'function') {
+    __allureAny_comm.step = async (_name, fn) => await fn();
+}
+/**
+ * Comm: Comment -text: {param}
+ *
+ * Logs a comment with variable substitution to the console.
+ * Useful for adding contextual information to the test log.
+ *
+ * Variables inside the message string (e.g., ${var.username}) will be replaced using `vars.replaceVariables`.
+ *
+ * @param message - The comment or message to log.
+ *
+ * @throws Error if `message` is not a non-empty string.
+ *
+ * @example
+ * Comm: Comment -text: "LAMBDA TEST COMPLETE"
+ */
+async function comment(message) {
+    if (typeof message !== 'string' || message.trim().length === 0) {
+        throw new Error('❌ comment: message must be a non-empty string.');
+    }
+    const formattedMessage = global_1.vars.replaceVariables(message);
+    if (isPlaywrightRunner()) {
+        await __allureAny_comm.step(`Comm: Comment -text: ${formattedMessage}`, async () => {
+            console.log(`💬 Comment: ${formattedMessage}`);
+        });
+    }
+    else {
+        console.log(`💬 Comment: ${formattedMessage}`);
+    }
+}
+/**
+ * Comm: Store -value: {param} in -variable: {param} -options: {param}
+ *
+ * Stores a value (with optional variable substitution) into a runtime variable.
+ *
+ * Variables inside the value string (e.g., ${var.username}) will be resolved using `vars.replaceVariables`.
+ *
+ * @param value - The value to store (can include variable references).
+ * @param varName - The name of the variable to store the resolved value into.
+ * @param options - Optional string or object with additional parameters (parsed if string). Currently unused but reserved for future logic.
+ *
+ * @throws Error if `varName` is not a non-empty string or `value` is undefined/null.
+ *
+ * @example
+ * Store -value: "${faker.string.alphanumeric({length:4})}" in -variable: "var.centre.code" -options: ""
+ */
+async function storeValue(value, varName, options) {
+    const options_json = typeof options === 'string' ? (0, vars_1.parseLooseJson)(options) : (options || {});
+    if (typeof varName !== 'string' || varName.trim().length === 0) {
+        throw new Error('❌ storeValue: varName must be a non-empty string.');
+    }
+    if (value === undefined || value === null) {
+        throw new Error('❌ storeValue: value must be provided.');
+    }
+    const resolvedValue = global_1.vars.replaceVariables(value);
+    if (isPlaywrightRunner()) {
+        await __allureAny_comm.step(`Comm: Store -value: ${resolvedValue} in -variable: ${varName} -options: ${JSON.stringify(options_json)}`, async () => {
+            global_1.vars.setValue(varName, resolvedValue);
+        });
+    }
+    else {
+        global_1.vars.setValue(varName, resolvedValue);
+    }
+}
+/**
+ * Comm: Attach-Log -message: {param} -mimeType: {param} -msgType: {param}
+ *
+ * Attach log or message to the test context (Cucumber or Playwright runner).
+ * @param message The message or buffer to attach
+ * @param mimeType The mime type (default: text/plain)
+ * @param msgType Optional label for the attachment (default: "Log").
+ *
+ * If `message` is empty or undefined, a warning is logged and no attachment is made.
+ */
+async function attachLog(message, mimeType, msgType) {
+    if (message === undefined || message === null || (typeof message === 'string' && message.length === 0)) {
+        console.warn('⚠️ attachLog: empty message provided; skipping attachment');
+        return;
+    }
+    if (!mimeType)
+        mimeType = "text/plain";
+    if (!msgType)
+        msgType = "Log";
+    if (isCucumberRunner()) {
+        const world = global_1.webFixture.getWorld();
+        if (world === null || world === void 0 ? void 0 : world.attach) {
+            await world.attach(message, mimeType);
+        }
+        else {
+            console.warn("⚠️ No World.attach() available in Cucumber context");
+        }
+    }
+    else if (isPlaywrightRunner()) {
+        try {
+            const anyAllure = allure;
+            if (typeof anyAllure.attachment === 'function') {
+                anyAllure.attachment(msgType, message, mimeType);
+            }
+            else if (typeof anyAllure.attach === 'function') {
+                anyAllure.attach(msgType || 'Log', message, mimeType);
+            }
+            else {
+                if (typeof message === 'string')
+                    console.log(message);
+            }
+        }
+        catch {
+            if (typeof message === 'string')
+                console.log(message);
+        }
+        // await playwrightTest
+        //   .info()
+        //   .attach("Log", { body: message, contentType: mimeType });
+    }
+    else {
+        console.warn("⚠️ attachLog: Unknown runner type");
+    }
+}
+/**
+ * Comm: Wait-In-Milli-Seconds -seconds: {param}
+ *
+ * Pauses execution for a given number of milliseconds.
+ * Logs a message using the test logger if available.
+ *
+ * @param ms - The number of milliseconds to wait.
+ *
+ * @throws Error if `ms` is not a finite number or is negative.
+ *
+ * @example
+ * Comm: Wait-In-Milli-Seconds -seconds: "1000"
+ */
+async function waitInMilliSeconds(ms) {
+    var _a;
+    if (typeof ms !== 'number' || !isFinite(ms) || ms < 0) {
+        throw new Error('❌ waitInMilliSeconds: ms must be a non-negative number.');
+    }
+    const logger = (_a = global_1.logFixture.getLogger) === null || _a === void 0 ? void 0 : _a.call(global_1.logFixture);
+    const doWait = async () => {
+        var _a;
+        (_a = logger === null || logger === void 0 ? void 0 : logger.info) === null || _a === void 0 ? void 0 : _a.call(logger, `⏳ Waiting for ${ms} ms`);
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    };
+    if (isPlaywrightRunner()) {
+        await __allureAny_comm.step(`Comm: Wait-In-Milli-Seconds -seconds: ${ms}`, async () => {
+            await doWait();
+        });
+    }
+    else {
+        await doWait();
+    }
+}

package/dist/helper/actions/comm/utilityActions.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Comm: Encrypt-Password -text: {param} -options: {param}
+ *
+ * Encrypts the given text as a password and returns it with a "pwd." prefix.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param options - Optional string or object of additional options (parsed if string).
+ * @returns A string prefixed with "pwd." followed by the encrypted value.
+ *
+ * @throws Error if `encryptText` is not a non-empty string.
+ *
+ */
+export declare function encryptPassword(encryptText: string, options?: string | Record<string, any>): Promise<any>;
+/**
+ * Comm: Encrypt-Text -text: {param} -options: {param}
+ *
+ * Encrypts the given text and returns it with an "enc." prefix.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param options - Optional string or object of additional options (parsed if string).
+ * @returns A string prefixed with "enc." followed by the encrypted value.
+ *
+ * @throws Error if `encryptText` is not a non-empty string.
+ *
+ */
+export declare function encryptText(encryptText: string, options?: string | Record<string, any>): Promise<any>;
+/**
+ * Comm: Encrypt-Password -text: {param} and store in -variable: {param} -options: {param}
+ *
+ * Encrypts the given password, prefixes it with "pwd.", and stores it in a variable.
+ *
+ * @param encryptText - The plain text password to encrypt.
+ * @param varNameToStore - The name of the variable to store the encrypted password.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptText` or `varNameToStore` are not non-empty strings.
+ *
+ */
+export declare function encryptPasswordAndStore(encryptText: string, varNameToStore: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Comm: Encrypt -text: {param} and store in -variable: {param} -options: {param}
+ *
+ * Encrypts the given text, prefixes it with "enc.", and stores it in a variable.
+ *
+ * @param encryptText - The text to encrypt.
+ * @param varNameToStore - The variable name to store the encrypted text.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptText` or `varNameToStore` are not non-empty strings.
+ *
+ */
+export declare function encryptTextAndStore(encryptText: string, varNameToStore: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Comm: Decrypt -text: {param} and store in -variable: {param} -options: {param}
+ *
+ * Decrypts the given encrypted text and stores the result in a variable.
+ *
+ * @param encryptedText - The encrypted value to decrypt.
+ * @param varName - The variable name to store the decrypted result.
+ * @param options - Optional string or object of additional options (parsed if string).
+ *
+ * @throws Error if `encryptedText` or `varName` are not non-empty strings.
+ *
+ */
+export declare function decrypt(encryptedText: string, varName: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Comm: Get-Random-From-List -arrayList: {param}
+ *
+ * Selects and returns a random item from a given non-empty array.
+ *
+ * @template T
+ * @param list - The array to select a random item from.
+ * @returns A randomly selected item from the array.
+ *
+ * @throws Error if the list is not a non-empty array.
+ *
+ */
+export declare function getRandomFromList<T>(list: T[]): Promise<T>;
+/**
+ * Comm: Remove-Leading-Zero-From-Date -text: {param}
+ *
+ * Removes leading zeros from both the day and month in a date string of format DD/MM/YYYY.
+ * Example: '03/07/2025' => '3/7/2025'
+ * @param dateStr - The date string in DD/MM/YYYY format
+ * @returns The date string with leading zeros removed from day and month
+ *
+ * @throws Error if `dateStr` is not a non-empty string.
+ */
+export declare function removeLeadingZeroFromMonthAndDate(dateStr: string): Promise<string>;
+interface WriteJsonOptions {
+    override?: boolean;
+    append?: boolean;
+    toArray?: boolean;
+}
+/**
+ * Comm: Write-JSON-To-File -filePath: {param} -data: {param} -options: {param}
+ *
+ * Writes JSON data to a file with options to override, append, or wrap in array.
+ *
+ * @param filePath - The destination file path.
+ * @param data - The JSON data to write (object or array).
+ * @param options - { override, append, toArray }
+ *
+ * @throws Error if `filePath` is empty, if append mode file content is not a JSON array, or if both `override` and `append` are false.
+ */
+export declare function writeJsonToFile(filePath: string, data: any, options?: WriteJsonOptions): Promise<void>;
+/**
+ * Ensures the value is formatted as a currency string: $<amount>.00
+ * @param value - The input value (number or string)
+ * @returns {string} - Formatted as $<amount>.00
+ */
+export declare function toDollarAmount(value: string | number): string;
+/**
+ * Comm: Generate TOTP Token to variable -varName: {param} -options: {param}
+ *
+ * Generates a TOTP (Time-based One-Time Password) token using the provided secret and stores it in a variable.
+ *
+ * @param varName - The name of the variable to store the generated TOTP token.
+ * @param options - Optional string or object containing:
+ *   - secret: [string] The TOTP secret key (default: process.env.PLAYQ_TOTP_SECRET_KEY).
+ *
+ * @example
+ * Comm: Generate TOTP Token to variable -varName: "var.otp" -options: '{"secret":"MYSECRET"}'
+ */
+export declare function generateTotpTokenToVariable(varName: string, options?: string | Record<string, any>): Promise<void>;
+/**
+ * Alias: wait
+ * Wrapper to maintain compatibility for step names mapping.
+ */
+export declare function wait(ms: number): Promise<void>;
+export {};