transit-core-taf 1.0.5 → 1.0.7

package/dist/transit-core-taf/baseui/basepagewaits.d.ts

@@ -51,4 +51,21 @@ export declare class BasePageWaits {
      * @param timeout - Optional timeout in milliseconds (default: 5000).
      */
     waitForElementToBeVisible(element: Locator, timeout?: number): Promise<void>;
+    /**
+     * Waits for a given element to be invisible on the page.
+     * @param element - The Playwright Locator of the element to wait for to be invisible.
+     * @param timeout - Optional timeout in milliseconds (default: 10000).
+     */
+    waitForElementToBeInvisible(element: Locator, timeout?: number): Promise<void>;
+    /**
+     * A generic wait function for a given element.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param options - Optional parameters for state and timeout.
+     * @param {('attached' | 'detached' | 'visible' | 'hidden')} [options.state='visible'] - The state to wait for.
+     * @param {number} [options.timeout=10000] - Optional timeout in milliseconds.
+     */
+    waitFor(element: Locator, options?: {
+        state?: 'attached' | 'detached' | 'visible' | 'hidden';
+        timeout?: number;
+    }): Promise<void>;
 }

package/dist/transit-core-taf/baseui/basepagewaits.js

@@ -165,5 +165,38 @@ class BasePageWaits {
             throw error;
         }
     }
+    /**
+     * Waits for a given element to be invisible on the page.
+     * @param element - The Playwright Locator of the element to wait for to be invisible.
+     * @param timeout - Optional timeout in milliseconds (default: 10000).
+     */
+    async waitForElementToBeInvisible(element, timeout = 10000) {
+        try {
+            this.logger.info(`🔍 Waiting for element to be invisible: ${element.toString()} (timeout: ${timeout}ms)`);
+            await element.waitFor({ state: 'hidden', timeout });
+        }
+        catch (error) {
+            this.logger.error(`❌ Element did not become invisible: ${element.toString()} within ${timeout}ms`);
+            throw error;
+        }
+    }
+    /**
+     * A generic wait function for a given element.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param options - Optional parameters for state and timeout.
+     * @param {('attached' | 'detached' | 'visible' | 'hidden')} [options.state='visible'] - The state to wait for.
+     * @param {number} [options.timeout=10000] - Optional timeout in milliseconds.
+     */
+    async waitFor(element, options) {
+        const { state = 'visible', timeout = 10000 } = options || {};
+        try {
+            this.logger.info(`🔍 Waiting for element ${element.toString()} to be ${state} (timeout: ${timeout}ms)`);
+            await element.waitFor({ state, timeout });
+        }
+        catch (error) {
+            this.logger.error(`❌ Element ${element.toString()} did not reach state ${state} within ${timeout}ms`);
+            throw error;
+        }
+    }
 }
 exports.BasePageWaits = BasePageWaits;

package/dist/transit-core-taf/index.d.ts

@@ -9,3 +9,5 @@ export * from './utils/Utils';
 export * from './baseapi/baseapihelpers';
 export * from './baseapi/apiutils';
 export * from './constants/test-tags';
+export * from './reporters/testrail-reporter';
+export * from './utils/testrail/client';

package/dist/transit-core-taf/index.js

@@ -25,3 +25,5 @@ __exportStar(require("./utils/Utils"), exports);
 __exportStar(require("./baseapi/baseapihelpers"), exports);
 __exportStar(require("./baseapi/apiutils"), exports);
 __exportStar(require("./constants/test-tags"), exports);
+__exportStar(require("./reporters/testrail-reporter"), exports);
+__exportStar(require("./utils/testrail/client"), exports);

package/dist/transit-core-taf/reporters/testrail-reporter.d.ts

@@ -0,0 +1,11 @@
+import { Reporter, FullConfig, Suite, TestCase, TestResult } from '@playwright/test/reporter';
+declare class TestRailReporter implements Reporter {
+    private client;
+    private runId;
+    private suiteId;
+    private enabled;
+    constructor();
+    onBegin(config: FullConfig, suite: Suite): Promise<void>;
+    onTestEnd(test: TestCase, result: TestResult): Promise<void>;
+}
+export default TestRailReporter;

package/dist/transit-core-taf/reporters/testrail-reporter.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@/utils/testrail/client");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+class TestRailReporter {
+    client = null;
+    runId = null;
+    suiteId = null;
+    enabled = false;
+    constructor() {
+        if (process.env.TESTRAIL_REPORTER_ENABLED === 'true') {
+            this.enabled = true;
+            try {
+                const host = process.env.TESTRAIL_HOST;
+                const user = process.env.TESTRAIL_USER;
+                const token = process.env.TESTRAIL_PASSWORD;
+                const projectId = process.env.TESTRAIL_PROJECT_ID;
+                if (!host || !user || !token || !projectId) {
+                    throw new Error('TestRail credentials are not fully set in environment variables.');
+                }
+                this.client = new client_1.TestRailClient(host, user, token, projectId);
+                const suiteIdEnv = process.env.TESTRAIL_SUITE_ID;
+                if (!suiteIdEnv) {
+                    throw new Error('TESTRAIL_SUITE_ID environment variable is not set.');
+                }
+                this.suiteId = parseInt(suiteIdEnv, 10);
+                if (isNaN(this.suiteId)) {
+                    throw new Error('TESTRAIL_SUITE_ID is not a valid number.');
+                }
+            }
+            catch (error) {
+                console.error('Failed to initialize TestRail reporter:', error);
+                this.enabled = false;
+            }
+        }
+        else {
+            console.log("TestRail reporter is disabled. Set TESTRAIL_REPORTER_ENABLED to 'true' to enable.");
+        }
+    }
+    async onBegin(config, suite) {
+        if (!this.enabled || !this.client || !this.suiteId)
+            return;
+        const timestamp = new Date().toLocaleString();
+        const runName = `Automated Test Run - ${timestamp}`;
+        const runDescription = `Playwright test run executed on ${timestamp}`;
+        try {
+            const run = await this.client.createTestRun(this.suiteId, runName, runDescription);
+            this.runId = run.id;
+        }
+        catch (error) {
+            console.error('Failed to create TestRail test run. Disabling reporter.');
+            this.enabled = false;
+        }
+    }
+    async onTestEnd(test, result) {
+        if (!this.enabled || !this.client || !this.runId)
+            return;
+        const caseIdRegex = /C(\d+)/;
+        const match = test.title.match(caseIdRegex);
+        if (match) {
+            const caseId = parseInt(match[1], 10);
+            const comment = result.status === 'failed' || result.status === 'timedOut'
+                ? `Test failed with error: ${result.error?.message}`
+                : `Test completed with status: ${result.status}`;
+            try {
+                await this.client.addResultForCase(this.runId, caseId, result.status, comment);
+                console.log(`Successfully reported result for Case C${caseId} to TestRail.`);
+            }
+            catch (error) {
+                console.error(`Failed to report result for Case C${caseId}.`);
+            }
+        }
+    }
+}
+exports.default = TestRailReporter;

package/dist/transit-core-taf/utils/testrail/client.d.ts

@@ -0,0 +1,15 @@
+declare const statusMap: {
+    [key: string]: number;
+};
+export declare class TestRailClient {
+    private host;
+    private user;
+    private token;
+    private projectId;
+    private auth;
+    constructor(host: string, user: string, token: string, projectId: string);
+    private apiPost;
+    createTestRun(suiteId: number, name: string, description: string): Promise<any>;
+    addResultForCase(runId: number, caseId: number, status: keyof typeof statusMap, comment?: string): Promise<any>;
+}
+export {};

package/dist/transit-core-taf/utils/testrail/client.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestRailClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const statusMap = {
+    passed: 1,
+    failed: 5,
+    timedOut: 5,
+    skipped: 2, // Mapped to 'Blocked'
+};
+class TestRailClient {
+    host;
+    user;
+    token;
+    projectId;
+    auth;
+    constructor(host, user, token, projectId) {
+        if (!host || !user || !token || !projectId) {
+            throw new Error('TestRail host, user, token, or project ID is missing.');
+        }
+        this.host = host;
+        this.user = user;
+        this.token = token;
+        this.projectId = projectId;
+        this.auth = `Basic ${Buffer.from(`${this.user}:${this.token}`).toString('base64')}`;
+    }
+    async apiPost(endpoint, data) {
+        const url = `${this.host}index.php?/api/v2/${endpoint}`;
+        try {
+            const response = await axios_1.default.post(url, data, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: this.auth,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`TestRail API Error: Failed to post to ${endpoint}.`, error.response ? error.response.data : error.message);
+            throw error;
+        }
+    }
+    async createTestRun(suiteId, name, description) {
+        console.log(`Creating TestRail Test Run for project ID: ${this.projectId}...`);
+        const data = {
+            suite_id: suiteId,
+            name,
+            description,
+            include_all: true,
+        };
+        const run = await this.apiPost(`add_run/${this.projectId}`, data);
+        console.log(`Successfully created Test Run with ID: ${run.id}`);
+        return run;
+    }
+    async addResultForCase(runId, caseId, status, comment) {
+        const status_id = statusMap[status];
+        if (status_id === undefined) {
+            console.warn(`Unknown test status: ${status}. Skipping TestRail update.`);
+            return;
+        }
+        const data = { status_id };
+        if (comment) {
+            data.comment = comment;
+        }
+        return this.apiPost(`add_result_for_case/${runId}/${caseId}`, data);
+    }
+}
+exports.TestRailClient = TestRailClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transit-core-taf",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Transit Core Automation Framework",
   "main": "dist/transit-core-taf/index.js",
   "types": "dist/transit-core-taf/index.d.ts",
@@ -20,6 +20,9 @@
     "typescript": "^5.0.0",
     "xlsx": "^0.18.5"
   },
+  "dependencies": {
+    "axios": "^1.7.2"
+  },
   "peerDependencies": {
     "playwright": "^1.54.1"
   },