vita-playwright 0.1.1

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "vita-playwright",
+  "version": "0.1.1",
+  "email": "noreply_testautomation@vialto.com",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "publish": "npm run build && npm publish --access public",
+    "prettier": "prettier --write \"**/*.ts\""
+  },
+  "dependencies": {
+    "@azure/storage-blob": "^12.11.0",
+    "@cucumber/cucumber": "7.3.1",
+    "@cucumber/html-formatter": "11.0.4",
+    "@cucumber/pretty-formatter": "1.0.0-alpha.0",
+    "@playwright/test": "^1.39.0",
+    "@types/lodash": "4.14.189",
+    "@types/node": "18.11.9",
+    "@typescript-eslint/eslint-plugin": "5.43.0",
+    "@typescript-eslint/parser": "5.43.0",
+    "allure-commandline": "^2.20.1",
+    "allure-cucumberjs": "2.0.0-beta.21",
+    "allure-playwright": "^2.0.0-beta.20",
+    "axios": "^0.27.2",
+    "crypto-js": "^4.1.1",
+    "cucumber-console-formatter": "1.0.0",
+    "dotenv": "^16.0.3",
+    "eslint": "8.28.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "is-ci": "2.0.0",
+    "lighthouse": "^9.6.8",
+    "lodash": "^4.17.21",
+    "moment": "^2.29.4",
+    "mssql": "9.0.0",
+    "nodemailer": "^6.9.1",
+    "open": "8.4.0",
+    "pdfreader": "^3.0.0",
+    "playwright": "^1.25.0",
+    "playwright-lighthouse": "^2.2.2",
+    "prettier": "2.7.1",
+    "rimraf": "3.0.2",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.3",
+    "xlsx": "^0.18.5",
+    "xmldom": "0.6.0"
+  },
+  "author": "Vialto QE",
+  "license": "ISC",
+  "description": "common functions for playwright and nodejs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Vialto/vialto-test-automation/",
+    "homepage": "https://github.com/Vialto/vialto-test-automation/#readme"
+  }
+}

package/src/helpers/api-helpers.ts

@@ -0,0 +1,38 @@
+import { TokenGenerators } from '../utils/api_axios';
+
+export class ApiHelper {
+    static async post(url: any, header: any, payload: any) {
+        const config = {
+            method: 'post',
+            url: url,
+            headers: header,
+            data: payload,
+        };
+
+        const response = await TokenGenerators.request(config);
+        return response;
+    }
+
+    static async get(url: any, header: any) {
+        const config = {
+            method: 'GET',
+            url: url,
+            headers: header,
+        };
+
+        const response = await TokenGenerators.request(config);
+        return response;
+    }
+
+    static async put(url: any, header: any, payload: any) {
+        const config = {
+            method: 'put',
+            url: url,
+            headers: header,
+            data: payload,
+        };
+
+        const response = await TokenGenerators.request(config);
+        return response;
+    }
+}

package/src/helpers/ui-helpers.ts

@@ -0,0 +1,148 @@
+//import robot from "robotjs";
+import { BrowserContext, chromium } from 'playwright';
+export class UIHelper {
+    page: any;
+    browser: BrowserContext;
+
+    constructor(page: any) {
+        this.page = page;
+    }
+
+    /* chromePath should be something like below 
+       <UserDirectory>/AppData/Local/Google/Chrome/User Data
+    */
+    async launchNonIncognito(chromePath: string) {
+        // Launch non-incognito session using provided chromePath
+        this.browser = await chromium.launchPersistentContext(chromePath, {
+            headless: false,
+        });
+        this.page = await this.browser.newPage();
+        this.browser.clearCookies();
+    }
+
+    // Close All the windows opened for non-incognito session
+    async closeNonIncognito() {
+        this.browser.clearCookies();
+        const allPages = this.browser.pages();
+        allPages.forEach((element) => {
+            element.close();
+        });
+    }
+
+    //Combines given list of cookies and generates a single cookie for passing in API as header
+    combineAllCookies(cookieJson) {
+        let Finalcookie: string = '';
+        for (let val of cookieJson) {
+            Finalcookie += val.name + '=' + val.value + ';';
+        }
+        console.log(
+            '\n----------------> Final Cookie Generated ---------------->\n'
+        );
+        Finalcookie = Finalcookie.toString().slice(0, -1);
+        return Finalcookie.toString();
+    }
+
+    async filltheData(locator: any, data: any) {
+        if (data) {
+            await this.waitTillElementIsVisible(locator);
+            await this.page.locator(locator).scrollIntoViewIfNeeded();
+            await this.page.locator(locator).fill(data);
+        }
+    }
+
+    async clickonWebElement(locator: any) {
+        await this.page.locator(locator).scrollIntoViewIfNeeded();
+        await this.waitTillElementIsVisible(locator);
+        await this.page.locator(locator).click();
+    }
+
+    async getInnerHTML(locator: any) {
+        await this.waitTillElementIsVisible(locator);
+        await this.page.locator(locator).scrollIntoViewIfNeeded();
+        return await this.page.innerHTML(locator);
+    }
+
+    async getInnerText(locator: any) {
+        await this.waitTillElementIsVisible(locator);
+        await this.page.locator(locator).scrollIntoViewIfNeeded();
+        return await this.page.locator(locator).innerText().trim();
+    }
+
+    async getText(locator: any) {
+        await this.waitTillElementIsVisible(locator);
+        await this.page.locator(locator).scrollIntoViewIfNeeded();
+        return await this.page.locator(locator).textContent();
+    }
+
+    async getAttribute(locator: any, attribute: any) {
+        await this.waitTillElementIsVisible(locator);
+        await this.page.locator(locator).scrollIntoViewIfNeeded();
+        return await this.page.locator(locator).getAttribute(attribute);
+    }
+
+    async evaluateJS(jsDOM: any) {
+        return await this.page.evaluate(jsDOM);
+    }
+
+    async isElementPresent(locator: any) {
+        // console.log(typeof locator.toString());
+        let type = typeof locator;
+        if (type === 'string') {
+            await this.page.locator(locator).scrollIntoViewIfNeeded();
+            return await this.page.locator(locator).isVisible();
+        } else if (type === 'object') {
+            return await locator.isVisible();
+        }
+
+        console.log(type);
+        console.log(type.toString());
+    }
+
+    async isElementEnabled(locator: any) {
+        await this.page.locator(locator).scrollIntoViewIfNeeded();
+        return await this.page.locator(locator).isEnabled();
+    }
+
+    async waitTillElementIsVisible(elementSelector: any, waitTime = 60000) {
+        await this.page.waitForSelector(elementSelector, {
+            waitFor: 'visible',
+            timeout: waitTime,
+        });
+    }
+
+    async getInputBoxValue(locator: any) {
+        await this.waitTillElementIsVisible(locator);
+        await this.page.locator(locator).scrollIntoViewIfNeeded();
+        return await this.page.inputValue();
+    }
+
+    // async closeCertificationPopup() {
+    //     await this.page.waitForTimeout(5000);
+    //     robot.moveMouse(400, 20);
+    //     robot.keyTap("enter");
+    // }
+
+    async downloadAFile(downloadButton: String, filePath: string) {
+        const downloadPromise = this.page.waitForEvent('download');
+        await this.clickonWebElement(downloadButton);
+        const download = await downloadPromise;
+        // Wait for the download process to complete
+        console.log('download', await download.path());
+        await download.saveAs(filePath);
+    }
+
+    async uploadAFile(uploadButton: String, uploadFilePath: String) {
+        const fileChooserPromise = this.page.waitForEvent('filechooser');
+        await this.clickonWebElement(uploadButton);
+        const fileChooser = await fileChooserPromise;
+        await fileChooser.setFiles(uploadFilePath);
+    }
+
+    async getElementRefByRole(roleType: string, roleName: string) {
+        return this.page.getByRole(roleType, { name: roleName });
+    }
+
+    async getElementLocatorByText(text: string) {
+        return this.page.getByText(text, { exact: true });
+    }
+}

package/src/utils/api_axios.ts

@@ -0,0 +1,16 @@
+import axios, { AxiosRequestConfig } from 'axios';
+
+export class TokenGenerators {
+    static generateKeyVaultAccessToken() {
+        throw new Error('Method not implemented.');
+    }
+    static async request(config: AxiosRequestConfig<any>) {
+        try {
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            const response = await axios(config);
+            return response;
+        } catch (error) {
+            return error.response;
+        }
+    }
+}

package/src/utils/azure_storage_methods.ts

@@ -0,0 +1,171 @@
+import { DOMParser } from 'xmldom';
+import { XmlToJson } from './xmlToJson';
+import HmacSHA256 from 'crypto-js/hmac-sha256';
+import Base64 from 'crypto-js/enc-base64';
+import { TokenGenerators } from './api_axios';
+import { BlobServiceClient } from '@azure/storage-blob';
+export class AzureStorageMethods {
+    static async getblobs(
+        storageAccount: any,
+        containerName: any,
+        storageAccountKey: any,
+        apiMethodName: string,
+        blobFilterName = ''
+    ) {
+        const header_date = new Date().toUTCString();
+        const apiMethod = apiMethodName.toUpperCase();
+
+        const url = new URL(
+            `https://${storageAccount}.blob.core.windows.net/${containerName}?restype=container&comp=list&prefix=${blobFilterName}`
+        );
+        const signatureParts = [
+            apiMethod,
+            '',
+            '',
+            '',
+            '',
+            '',
+            '',
+            '',
+            '',
+            '',
+            '',
+            '',
+        ];
+
+        const canonicalHeaderParts = [];
+        canonicalHeaderParts.push(`x-ms-date:${header_date}`);
+        canonicalHeaderParts.push(`x-ms-version:2018-03-28`);
+
+        // Add headers to signature
+        signatureParts.push.apply(signatureParts, canonicalHeaderParts);
+
+        // Construct CanonicalizedResource
+        const canonicalResourceParts = [`/${storageAccount}${url.pathname}`];
+        const canonicalQueryNames: string[] = [];
+        url.searchParams.forEach((value, key) => {
+            canonicalQueryNames.push(key.toLowerCase());
+        });
+        canonicalQueryNames.sort();
+        canonicalQueryNames.forEach((queryName) => {
+            const value = url.searchParams.get(queryName);
+
+            canonicalResourceParts.push(`${queryName}:${value}`);
+        });
+        // Add resource to signature
+        signatureParts.push.apply(signatureParts, canonicalResourceParts);
+
+        // Now, construct signature raw string
+        const signatureRaw = signatureParts.join('\n');
+
+        // Hash it using HMAC-SHA256 and then encode using base64
+
+        const signatureBytes = HmacSHA256(
+            signatureRaw,
+            Base64.parse(storageAccountKey)
+        );
+        const signatureEncoded = signatureBytes.toString(Base64);
+
+        const config = {
+            method: apiMethod,
+            url: `https://${storageAccount}.blob.core.windows.net/${containerName}?restype=container&comp=list&prefix=${blobFilterName}`,
+            headers: {
+                Authorization: `SharedKey ${storageAccount}:${signatureEncoded}`,
+                'x-ms-date': header_date,
+                'x-ms-version': '2018-03-28',
+            },
+        };
+
+        const response = await TokenGenerators.request(config);
+        const apiData = response.data;
+        const XmlNode = new DOMParser().parseFromString(apiData, 'text/xml');
+        const jsonObj = await XmlToJson.xmlToJson(XmlNode);
+        const blobs = jsonObj.EnumerationResults.Blobs.Blob;
+        const newBlobs = [];
+        if (blobs.length) {
+            for (let i = 0; i < blobs.length; i++) {
+                const blob = {
+                    fileName: blobs[i].Name['#text'].replace(
+                        blobFilterName,
+                        ''
+                    ),
+                    modifiedTime: Date.parse(
+                        blobs[i].Properties['Last-Modified']['#text']
+                    ),
+                    status:
+                        Math.floor(
+                            Date.now() -
+                                Date.parse(
+                                    blobs[i].Properties['Last-Modified'][
+                                        '#text'
+                                    ]
+                                ) /
+                                    1000
+                        ) > 30
+                            ? 1
+                            : 0,
+                };
+                newBlobs.push(blob);
+            }
+        } else if (blobs.fileName) {
+            const blob = {
+                fileName: blobs.Name['#text'].replace(blobFilterName, ''),
+                modifiedTime: Date.parse(
+                    blobs.Properties['Last-Modified']['#text']
+                ),
+                status:
+                    Math.floor(
+                        Date.now() -
+                            Date.parse(
+                                blobs.Properties['Last-Modified']['#text']
+                            ) /
+                                1000
+                    ) > 30
+                        ? 1
+                        : 0,
+            };
+            newBlobs.push(blob);
+        }
+
+        newBlobs.sort((a, b) =>
+            a.fileName > b.fileName ? 1 : b.fileName > a.fileName ? -1 : 0
+        );
+        newBlobs.sort((a, b) =>
+            a.modifiedTime < b.modifiedTime
+                ? 1
+                : b.modifiedTime < a.modifiedTime
+                ? -1
+                : 0
+        );
+
+        return newBlobs;
+    }
+
+    static async createBlobByUploadingData(
+        storageAccount: string,
+        sasToken: string,
+        containerName: string,
+        filepath: string,
+        fileNameWithExtension: string
+    ) {
+        const blobServiceClient = new BlobServiceClient(
+            'https://' +
+                storageAccount +
+                '.blob.core.windows.net/' +
+                '?' +
+                sasToken
+        );
+        const containerClient =
+            blobServiceClient.getContainerClient(containerName);
+
+        const blockBlobClient = containerClient.getBlockBlobClient(
+            fileNameWithExtension
+        );
+
+        const uploadBlobResponse = await blockBlobClient.uploadFile(filepath);
+
+        console.log(
+            `Block blob ${fileNameWithExtension} uploaded successfully`
+        );
+    }
+}

package/src/utils/comparisions.ts

@@ -0,0 +1,99 @@
+import { expect } from '@playwright/test';
+import { isDeepStrictEqual } from 'util';
+import _ from 'lodash';
+
+export class Comparisions {
+    static async compareObjects(actualObj: string, expectedObj: string) {
+        let same;
+        console.log(
+            'Actual Obj: ' + actualObj + ' and Expected Obj: ' + expectedObj
+        );
+        same = _.isEqual(actualObj, expectedObj);
+        console.log(same);
+        return same;
+    }
+
+    static async compareUnorderedJSONObjects(
+        actualObj: { [x: string]: any },
+        expectedObj: { [x: string]: any }
+    ) {
+        const Keydata = Object.keys(expectedObj);
+        const result = new Array();
+        let boolean;
+        for (let i = 0; i < Keydata.length; i++) {
+            if (actualObj[Keydata[i]] == expectedObj[Keydata[i]]) {
+                result.push(true);
+            } else {
+                result.push(false);
+            }
+        }
+        boolean = result.includes(false) ? false : true;
+        return boolean;
+    }
+
+    static areJsonFilesEqual(receivedJson, expectedJson): Boolean {
+        let isJsonEqual = true;
+        let receivedKeys: string[] = this.getJsonKeys(receivedJson);
+        let expectedKeys = this.getJsonKeys(expectedJson);
+        let receivedValues = this.getJsonValues(receivedJson);
+        let expectedValues = this.getJsonValues(expectedJson);
+        let count: number = this.getJsonCount(receivedJson);
+
+        for (let i: number = 0; i < count; i++) {
+            let receivedKey = receivedKeys[i];
+            let expectedKey = expectedKeys[i];
+            let receivedValue = receivedValues[i];
+            let expectedValue = expectedValues[i];
+
+            let isKeyEmpty: Boolean = receivedKey == (null || '');
+            let isKeyEqual: Boolean = receivedKey == expectedKey;
+            let isValueEqual: Boolean = isDeepStrictEqual(
+                receivedValue,
+                expectedValue
+            );
+            expect.soft(!isKeyEmpty, 'Actual Key received is not null.');
+            expect
+                .soft(
+                    isKeyEqual,
+                    "Actual key received is: '" +
+                        receivedKey +
+                        "' and expected key is: '" +
+                        expectedKey +
+                        "'."
+                )
+                .toBeTruthy();
+            expect
+                .soft(
+                    isValueEqual,
+                    "Actual value received for '" +
+                        expectedKey +
+                        "' is " +
+                        JSON.stringify(receivedValue) +
+                        ' and \nExpected value is: ' +
+                        JSON.stringify(expectedValue) +
+                        '.'
+                )
+                .toBeTruthy();
+
+            if (isKeyEmpty || !isKeyEqual || !isValueEqual) {
+                isJsonEqual = false;
+            }
+        }
+        return isJsonEqual;
+    }
+
+    //Get Keys from Json Files
+    static getJsonKeys(jsonFile) {
+        return Object.keys(jsonFile);
+    }
+
+    //Get Values From Json Files
+    static getJsonValues(jsonFile) {
+        return Object.values(jsonFile);
+    }
+
+    //Get Count of Json items
+    static getJsonCount(jsonFile) {
+        return Object.keys(jsonFile).length;
+    }
+}

package/src/utils/date_utilitites.ts

@@ -0,0 +1,39 @@
+import { map } from 'lodash';
+import moment, { DurationInputArg1, DurationInputArg2 } from 'moment';
+export class Dateutility {
+    static getDateInCustomFormat(date: any, format: string) {
+        return moment(date).format(format);
+    }
+
+    static getFutureDateInCustomFormat(
+        date: any,
+        format: string,
+        durationType: DurationInputArg2,
+        duration: DurationInputArg1
+    ) {
+        return moment(date).add(duration, durationType).format(format);
+    }
+
+    static getPastDateInCustomFormat(
+        date: any,
+        format: string,
+        durationType: DurationInputArg2,
+        duration: DurationInputArg1
+    ) {
+        return moment(date).subtract(duration, durationType).format(format);
+    }
+
+    static getMinDateFromMultipleDates(datesArrayObject: any) {
+        return moment.min(
+            map(datesArrayObject, (obj) => moment(obj.date, obj.format))
+        );
+    }
+
+    static getMaxDateFromMultipleDates(date1: any, date2: any) {
+        return moment.max(date1, date2);
+    }
+
+    static calculateRelativeDate(fromDate: any, format: string) {
+        return moment(fromDate, format).fromNow();
+    }
+}

package/src/utils/document_utility.ts

@@ -0,0 +1,81 @@
+import XLSX from 'xlsx';
+import _ from 'lodash';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+// import { PdfReader } from 'pdfreader';
+
+export class DocumentUtility {
+    static async readData(filePath: string) {
+        return XLSX.readFile(filePath, {
+            cellDates: true,
+            bookVBA: true,
+            sheetStubs: true,
+            cellNF: true,
+        });
+    }
+
+    static async readDataFromExcelorCSV(filePath: string, sheetname: string) {
+        const jsonOpts = {
+            raw: false,
+            dateNF: `yyyy/mm/dd`, // <--- need dateNF in sheet_to_json options (note the escape chars)
+        };
+        const workbook = await DocumentUtility.readData(filePath);
+        const sheet_name_list = workbook.SheetNames;
+        sheetname = sheetname === undefined ? sheet_name_list[0] : sheetname;
+        return XLSX.utils.sheet_to_json(
+            workbook.Sheets[sheet_name_list[0]],
+            jsonOpts
+        );
+
+        // const tempTwoDimentionalArr = new Array(_.keys(excelData[0]).length);
+        // for (const i = 0; i < tempTwoDimentionalArr.length; i++) {
+        //     tempTwoDimentionalArr[i] = new Array();
+        // }
+        // return _.map(excelData,  (obj)=> {
+        //     return _.reduce(_.keys(excelData[0]),  (result, columnName, index) =>{
+        //         tempTwoDimentionalArr[index].push(obj[columnName])
+        //         result[columnName] = tempTwoDimentionalArr[index];
+        //         return result;
+        //     }, {})
+        // })[0];
+    }
+
+    static async filterData(
+        filePath: string,
+        sheetName: string,
+        filterObject: object
+    ) {
+        let fileData = await DocumentUtility.readData(filePath);
+        return _.filter(
+            XLSX.utils.sheet_to_json(fileData.Sheets[sheetName]),
+            filterObject
+        );
+    }
+
+    static async updateExcelData(
+        filePath: string,
+        sheetName: string,
+        exportData: Array<object>
+    ) {
+        const workbook = await DocumentUtility.readData(filePath);
+        workbook.Sheets[sheetName] = XLSX.utils.json_to_sheet(exportData);
+        XLSX.writeFile(workbook, filePath);
+    }
+
+    static async deleteAllFilesUnderDir(dirPath: string) {
+        for (const file of await fs.readdir(dirPath)) {
+            await fs.unlink(path.join(dirPath, file));
+        }
+    }
+
+    // static async readPdfFile(filePath: string) {
+    //     const items = [];
+    //     return new Promise((resolve, reject) => {
+    //         new PdfReader().parseFileItems(filePath, (err, item) => {
+    //             if (err) reject(err);
+    //             else if (!item) resolve(items);
+    //             else if (item.text) items.push(item.text);
+    //         });
+    //     });
+    // }
+}

package/src/utils/email_sender.ts

@@ -0,0 +1,36 @@
+import nodemailer from 'nodemailer';
+export class EmailSender {
+    static async transporter() {
+        return nodemailer.createTransport({
+            service: 'Gmail',
+            host: 'smtp.gmail.com',
+            secure: false,
+            auth: {
+                user: '***********',
+                pass: '***********',
+            },
+        });
+    }
+
+    static async getMailOptions() {
+        return {
+            from: 'durgaprasad555555@gmail',
+            to: 'vemula.d.prasad.tpr@vialto.com',
+            subject: 'this testing mail from automation',
+            html: `<h2 style="color:#ff6600;">Hello People!, 
+                      Welcome to Vialto!</h2>`,
+            attachments: [{ filename: 'test.js', path: './resources/test.js' }],
+        };
+    }
+
+    static async sendMail() {
+        const transporter = await this.transporter();
+        transporter.sendMail(this.getMailOptions(), (error, info) => {
+            if (error) {
+                console.log(error);
+            } else {
+                console.log('email sent: ' + info.message);
+            }
+        });
+    }
+}