@auxcode/auxta 0.4.4 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auxcode/auxta",
-  "version": "0.4.4",
+  "version": "0.4.8",
   "description": "",
   "main": "src/AuxTA.ts",
   "scripts": {

package/src/AuxTA.ts

@@ -1,13 +1,13 @@
-import puppeteer, { Puppeteer } from "./puppeteer/puppeteer";
-import { FunctionHelper } from "./macros/helpers/code.helper";
+import puppeteer, {Puppeteer} from "./puppeteer/puppeteer";
+import {FunctionHelper} from "./macros/helpers/code.helper";
 import path from "path";
 import fs from "fs";
 import StatusOfStep from "./auxta/enums/status-of.step";
-import { UploadModel } from "./auxta/models/upload.model";
+import {UploadModel} from "./auxta/models/upload.model";
 import * as dotenv from "dotenv";
-import { setupConfig, config as c, setupOverrideConfig } from "./auxta/configs/config";
-import { startSuite } from "./auxta/utilities/start-suite.helper";
-import { createEmptyReport } from "./auxta/services/report.service";
+import {setupConfig, config as c, setupOverrideConfig} from "./auxta/configs/config";
+import {startSuite} from "./auxta/utilities/start-suite.helper";
+import {createEmptyReport} from "./auxta/services/report.service";
 
 dotenv.config();
 
@@ -41,7 +41,7 @@ class AuxTA extends FunctionHelper {
             } catch (e) {
                 console.log("Missing field in auxta.json:", e)
             }
-            this.uploadModel = new UploadModel(jsonConfig.organization, jsonConfig.baseURL, jsonConfig.digitalProduct,jsonConfig.environment);
+            this.uploadModel = new UploadModel(jsonConfig.organization, jsonConfig.baseURL, jsonConfig.digitalProduct, jsonConfig.environment);
         } catch (e) {
             console.log("Missing or corrupted config: auxta.json. Searching in location:", file)
             console.log(e);
@@ -58,7 +58,8 @@ class AuxTA extends FunctionHelper {
         await startSuite(suites, reportId || await createEmptyReport(this.uploadModel));
         return {statusCode: 204}
     }
-    private changeModelData(overrideConfig?: any){
+
+    private changeModelData(overrideConfig?: any) {
         if (overrideConfig) {
             if (overrideConfig.digitalProduct) this.uploadModel.digitalProduct = overrideConfig.digitalProduct
             if (overrideConfig.environment) this.uploadModel.environment = overrideConfig.environment
@@ -78,6 +79,15 @@ class AuxTA extends FunctionHelper {
         return this.puppeteer.run(event, callback, feature, scenario)
     }
 
+    public async startBrowserRPA(event: any, callback: any, baseURL: string) {
+        this.changeModelData({
+            baseURL: baseURL,
+            environment: '',
+            digitalProduct: ''
+        });
+        return this.puppeteer.runRPA(event, callback)
+    }
+
     public getUploadModel(): UploadModel {
         return this.uploadModel;
     }

package/src/macros/helpers/code.helper.ts

@@ -6,22 +6,22 @@ import { config } from "../../auxta/configs/config";
 export class FunctionHelper {
     public readonly defaultTimeout: number = config.timeout;
 
-    public log(keyword: string, name: string, status: StatusOfStep){
+    public log(keyword: string, name: string, status: StatusOfStep) {
         log.push(keyword, name, status)
     }
 
-    public suggest(name: string){
+    public suggest(name: string) {
         log.addSuggestion(name)
     }
 
-    private getEscapedText(text: string){
+    private getEscapedText(text: string) {
         const splitedQuotes = text.replace(/'/g, `', "'", '`)
         return `concat('${splitedQuotes}', '')`;
     }
 
     public async clickByText(selector: string, text: string, page = puppeteer.defaultPage, dotOrText = '.') {
         const message = `I click on the '${text}' '${selector}'`;
-        try{
+        try {
             const [linkHandlers] = await page.$x(`//${selector}[${dotOrText} = ${this.getEscapedText(text)}]`);
 
             if (linkHandlers) {
@@ -29,15 +29,30 @@ export class FunctionHelper {
                 log.push('Then', message, StatusOfStep.PASSED);
                 return;
             }
-        } catch (e){
+        } catch (e) {
         }
         log.push('Then', message, StatusOfStep.FAILED);
         throw new Error(message);
     }
+    public async clickByTextWithClass(class_selector: string, class_name: string, selector: string, text: string, page = puppeteer.defaultPage, dotOrText = '.') {
+        const message = `I click on the '${text}' '${selector}'`;
+        try {
+            const [linkHandlers] = await page.$x(`//${class_selector}[contains(@class,${this.getEscapedText(class_name)})]//${selector}[${dotOrText} = ${this.getEscapedText(text)}]`);
 
+            if (linkHandlers) {
+                await linkHandlers.click();
+                log.push('Then', message, StatusOfStep.PASSED);
+                return;
+            }
+        } catch (e) {
+        }
+        log.push('Then', message, StatusOfStep.FAILED);
+        throw new Error(message);
+    }
+    //div[contains(@class,"mat-menu-content")]//button
     public async waitForSelectorWithText(selector: string, text: string, page = puppeteer.defaultPage, dotOrText = '.') {
         const message = `I check for '${text}' on the current page`;
-        try{
+        try {
             await page.waitForSelector(selector, {
                 timeout: this.defaultTimeout
             });
@@ -46,7 +61,7 @@ export class FunctionHelper {
                 log.push('And', message, StatusOfStep.PASSED);
                 return true;
             }
-        }catch (e) {
+        } catch (e) {
         }
         log.push('And', message, StatusOfStep.FAILED);
         throw new Error(message);
@@ -58,7 +73,7 @@ export class FunctionHelper {
     }
 
     public async type(field: string, value: string, page = puppeteer.defaultPage) {
-        try{
+        try {
             await page.waitForSelector(field, {
                 timeout: this.defaultTimeout
             });
@@ -66,7 +81,7 @@ export class FunctionHelper {
             let elementName = await page.$eval(field, (e) => e.textContent);
             if (!elementName || elementName === ' ') elementName = field;
             log.push('Then', `I type '${value}' into the '${elementName}' field`, StatusOfStep.PASSED);
-        } catch (e){
+        } catch (e) {
             const msg = `I type '${value}' into the '${field}' field`
             log.push('Then', msg, StatusOfStep.FAILED);
             throw new Error(msg)
@@ -75,10 +90,10 @@ export class FunctionHelper {
 
     public async waitForNetwork(page = puppeteer.defaultPage) {
         let message = 'I wait for the page to load'
-        try{
+        try {
             await page.waitForNetworkIdle();
             log.push('Then', message, StatusOfStep.PASSED);
-        } catch (e){
+        } catch (e) {
             log.push('Then', message, StatusOfStep.FAILED);
             throw new Error(message)
         }
@@ -99,14 +114,14 @@ export class FunctionHelper {
      * @param log_message
      */
 
-    public async waitForSelector(option: string, selector: string, time: number = this.defaultTimeout, page = puppeteer.defaultPage,log_message = true) {
+    public async waitForSelector(option: string, selector: string, time: number = this.defaultTimeout, page = puppeteer.defaultPage, log_message = true) {
         const message = `I check for the '${selector}' element to be ${option}`;
-        try{
+        try {
             await page.waitForSelector(selector, {
                 [option]: true,
                 timeout: time
             });
-        } catch (e){
+        } catch (e) {
             if (log_message) {
                 log.push('And', message, StatusOfStep.FAILED);
             }
@@ -118,7 +133,7 @@ export class FunctionHelper {
     }
 
     public async click(selector: string, logMessages = true, page = puppeteer.defaultPage) {
-        try{
+        try {
             await page.waitForSelector(selector, {
                 timeout: this.defaultTimeout
             });
@@ -126,7 +141,7 @@ export class FunctionHelper {
             if (!elementName || elementName === ' ') elementName = selector;
             await page.click(selector);
             log.push('Then', `I click on the '${elementName}'`, StatusOfStep.PASSED);
-        } catch (e){
+        } catch (e) {
             const msg = `I click on the '${selector}'`;
             log.push('Then', msg, StatusOfStep.FAILED);
             throw new Error(msg)
@@ -143,6 +158,38 @@ export class FunctionHelper {
         log.push('And', message, StatusOfStep.PASSED);
     }
 
+    public async pressEnter(page = puppeteer.defaultPage) {
+        await page.keyboard.press('Enter');
+    }
+
+    //TODO work in progress
+    /*
+    private async microsoftLogin(button: string, email: string, password: string) {
+        const email_input = 'input[type="email"]';
+        const password_input = 'input[type="password"]';
+        const no_button = 'input[type="button"]';
+        // click on login button
+        const nav = new Promise(res => puppeteer.defaultPage.browser().on('targetcreated', res));
+        await this.click(button);
+        await nav;
+        const pages = await puppeteer.defaultPage.browser().pages();
+        const loginPage = pages[pages.length - 1];
+        // enter password and submit
+        await this.waitForSelector('visible', email_input, 60000, loginPage);
+        await this.type(email_input, email, loginPage);
+        await this.pressEnter(loginPage);
+        await this.waitForNetwork(loginPage);
+        // enter password and submit
+        await this.waitForSelector('visible', password_input, 60000, loginPage);
+        await this.type(password_input, password, loginPage);
+        await this.pressEnter(loginPage);
+        await this.waitForNetwork(loginPage);
+        // press no
+        await this.waitForSelector('visible', no_button, 60000, loginPage);
+        await this.click(no_button, true, loginPage);
+        await this.waitForNetwork(loginPage);
+    }*/
+
 }
 
 export default new FunctionHelper();

package/src/puppeteer/puppeteer.ts

@@ -1,13 +1,13 @@
 import chromium from 'chrome-aws-lambda';
 import log from "../auxta/services/log.service";
-import { captureScreenshot } from "../auxta/utilities/screenshot.helper";
-import { onTestEnd } from "../auxta/hooks/report.hook";
+import {captureScreenshot} from "../auxta/utilities/screenshot.helper";
+import {onTestEnd} from "../auxta/hooks/report.hook";
 import auxta from "../AuxTA";
-import { StatusOfStep } from "../auxta/enums/status-of.step";
-import { UploadModel } from "../auxta/models/upload.model";
+import {StatusOfStep} from "../auxta/enums/status-of.step";
+import {UploadModel} from "../auxta/models/upload.model";
 import puppeteer_core from 'puppeteer-core';
-import { config } from "./../auxta/configs/config";
-import { postNotificationsOnFail } from "../auxta/services/report.service";
+import {config} from "./../auxta/configs/config";
+import {postNotificationsOnFail} from "../auxta/services/report.service";
 
 
 export class Puppeteer {
@@ -16,7 +16,11 @@ export class Puppeteer {
 
     public async startBrowser() {
         let args = [
-            '--start-maximized'
+            '--start-maximized',
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            '--disable-dev-shm-usage',
+            '--single-process'
         ];
         if (process.env.ENVIRONMENT != 'LOCAL')
             args.push(`--window-size=${config.screenWidth},${config.screenHeight}`)
@@ -45,7 +49,7 @@ export class Puppeteer {
     }
 
     public async run(event: any, callback: any, featureName = 'Test feature', scenarioName = 'Test scenario', uploadModel?: UploadModel, close?: boolean) {
-        try{
+        try {
             if (uploadModel === undefined) uploadModel = auxta.getUploadModel();
             if (close === undefined) close = Puppeteer.setupHeader(event, uploadModel)
             let screenshotBuffer: Buffer | undefined;
@@ -81,13 +85,51 @@ export class Puppeteer {
                 console: consoleStack,
                 error: errMessage
             });
-        } catch (e){
+        } catch (e) {
             console.log("Lib error:", e);
         } finally {
             log.clear();
         }
     }
 
+    public async runRPA(event: any, callback: any, close?: boolean) {
+        let errMessage: any;
+        try {
+            if (close === undefined) {
+                if (event.queryStringParameters.close) {
+                    close = event.queryStringParameters.close === "true";
+                } else {
+                    close = true
+                }
+            }
+            let consoleStack: any[] = [];
+            try {
+                await log.push('When', `Starting puppeteer process`, StatusOfStep.PASSED);
+                await this.startBrowser()
+                this.defaultPage.on('console', message =>
+                    consoleStack.push(`${message.type().substr(0, 3).toUpperCase()} ${message.text()}`))
+                    .on('pageerror', ({message}) => consoleStack.push(message))
+                    .on('response', response =>
+                        consoleStack.push(`${response.status()} ${response.url()}`))
+                    .on('requestfailed', request =>
+                        consoleStack.push(`${request.failure() !== null ? request.failure()?.errorText : ""} ${request.url()}`))
+                await callback(event)
+                log.push('When', `Finished puppeteer process`, StatusOfStep.PASSED);
+            } catch (err) {
+                console.log("Error", err);
+                errMessage = err;
+                log.push('When', `Finished puppeteer process`, StatusOfStep.FAILED);
+                return errMessage;
+            }
+            if (close) await this.close();
+        } catch (e) {
+            console.log("Lib error:", e);
+        } finally {
+            log.clear();
+
+        }
+    }
+
     private static setupHeader(event: any, uploadModel: UploadModel) {
         let close = true;
         if (process.env.ENVIRONMENT !== 'LOCAL' && event.body) {