@auxcode/auxta 0.1.3 → 0.1.7

package/package.json

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

package/src/AuxTA.ts

@@ -1,46 +1,68 @@
 import puppeteer, { Puppeteer } from "./puppeteer/puppeteer";
 import { FunctionHelper } from "./macros/helpers/code.helper";
-import f from "./macros/helpers/code.helper";
-import run from "./auxta/run";
-import { Log } from "./auxta/services/log.service";
-import defaultLog from "./auxta/services/log.service";
 import path from "path";
 import fs from "fs";
-import { StepStatusEnum } from "./auxta/enums/step-status.enum";
+import StepStatusEnum from "./auxta/enums/step-status.enum";
 import { UploadModel } from "./auxta/models/upload.model";
 import * as dotenv from "dotenv";
-import { setupConfig } from "./auxta/configs/config";
+import { config, setupConfig } from "./auxta/configs/config";
+import { startSuite } from "./auxta/utilities/start-suite.helper";
+import { createEmptyReport } from "./auxta/services/report.service";
 
 dotenv.config();
 
-class AuxTA {
+class AuxTA extends FunctionHelper {
     public puppeteer: Puppeteer = puppeteer;
-    public func: FunctionHelper = f;
-    public run: Function = run;
-    public logger: Log.LogSteps = defaultLog;
 
     private readonly uploadModel: UploadModel;
 
     constructor() {
+        super();
         let file;
         try {
             //todo find a better way to load the file
-            file = path.join(__dirname, "../../../../../../", "suitesList.json");
+            let currentDir = "../"
+            while (true) {
+                file = path.join(__dirname, currentDir, "auxta.json");
+                try {
+                    fs.accessSync(file, fs.constants.R_OK | fs.constants.W_OK)
+                    break;
+                } catch {
+                    currentDir += "../"
+                    if (currentDir.length >= 30) {
+                        process.exit(1);
+                        return;
+                    }
+                }
+            }
             const jsonConfig = JSON.parse(fs.readFileSync(file).toString());
             try {
                 setupConfig(jsonConfig)
-            } catch (e) {
-                if (e instanceof Error) console.log("Missing field in suitesList.json:", e.message)
-                process.exit(1);
+            } catch (e: any) {
+                console.log("Missing field in auxta.json:", e.message)
             }
             this.uploadModel = new UploadModel(jsonConfig.organization, jsonConfig.baseURL, jsonConfig.digitalProduct);
-        } catch (e) {
+        } catch (e: any) {
             console.log("Missing or corrupted config: suitesList.json. Searching in location:", file)
             console.log(e);
             process.exit(1);
         }
     }
 
+    public async run(event: any) {
+        const model = this.uploadModel;
+        let token: string = event.queryStringParameters.token;
+        let reportId: string | undefined = event.queryStringParameters.reportId;
+        if (token !== config.token) return {statusCode: 401, message: 'Unauthorized'}
+        const suites = config.suitesList.slice(0);
+        await startSuite(suites, reportId || await createEmptyReport(model));
+        return {statusCode: 204}
+    }
+
+    public startBrowser(event: any, callback: any, feature: string, scenario: string) {
+        this.puppeteer.run(event, callback, feature, scenario)
+    }
+
     public getUploadModel(): UploadModel {
         return this.uploadModel;
     }
@@ -50,11 +72,4 @@ export const StepStatus = StepStatusEnum;
 
 const auxta: AuxTA = new AuxTA();
 
-export const auxtaLogger = auxta.logger;
-export const auxtaPuppeteer = auxta.puppeteer;
-export const auxtaSuggest = auxta.logger.addSuggestion;
-export const auxtaLog = auxta.logger.push;
-export const auxtaRun = auxta.run;
-export const auxtaFunc = auxta.func;
-
 export default auxta;

package/src/auxta/enums/step-status.enum.ts

@@ -4,3 +4,4 @@ export enum StepStatusEnum {
     SKIPPED = 'skipped',
     SUGGESTION = 'suggestion',
 }
+export default StepStatusEnum;

package/src/auxta/hooks/report.hook.ts

@@ -10,7 +10,7 @@ import {
 } from '../services/report.service';
 import { startSuite } from '../utilities/start-suite.helper';
 import { StepStatusEnum } from "../enums/step-status.enum";
-import UploadModel from "../models/upload.model";
+import { UploadModel } from "../models/upload.model";
 
 export async function AfterEach(body: any, featureName: string, scenarioName: string, statusCode: number, screenshotBuffer: Buffer, errMessage?: string) {
     let isFinal: boolean = false;

package/src/auxta/models/upload.model.ts

@@ -48,5 +48,3 @@ export class UploadModel {
         return this._environment;
     }
 }
-
-export default UploadModel;

package/src/auxta/services/log.service.ts

@@ -1,46 +1,52 @@
 import { StepStatusEnum } from "../enums/step-status.enum";
 
-export namespace Log {
-    export interface Step {
-        keyword: string,
-        name: string,
-        result: {
-            status: StepStatusEnum,
-            duration: number
-        }
+export interface Step {
+    keyword: string,
+    name: string,
+    result: {
+        status: StepStatusEnum,
+        duration: number
+    }
+}
+
+export class LogSteps {
+    private stepLog: Step[] = [];
+    private lastStepTime = new Date().getTime();
+    public statusCounter = {
+        [StepStatusEnum.PASSED]: 0,
+        [StepStatusEnum.FAILED]: 0,
+        [StepStatusEnum.SKIPPED]: 0,
+        [StepStatusEnum.SUGGESTION]: 0,
+    }
+
+    public addSuggestion(text: string) {
+        this.statusCounter[StepStatusEnum.SUGGESTION]++;
+        this.stepLog.push({
+            keyword: 'Suggestion', name: text, result:
+                {status: StepStatusEnum.SUGGESTION, duration: 0}
+        });
+    }
+
+    public clear() {
+        this.stepLog = [];
+    }
+
+    public push(keyword: string, name: string, status: StepStatusEnum) {
+        console.log(`System log -- status: ${status} -- : ${name} `);
+        this.statusCounter[status]++;
+        const currentStep = new Date().getTime();
+        this.stepLog.push({keyword, name, result: {status, duration: currentStep - this.lastStepTime}});
+        this.lastStepTime = currentStep;
+    }
+
+    public returnScenarioReport() {
+        return this.stepLog;
     }
 
-    export class LogSteps {
-        private stepLog: Log.Step[] = [];
-        private statusCounter = {
-            [StepStatusEnum.PASSED]: 0,
-            [StepStatusEnum.FAILED]: 0,
-            [StepStatusEnum.SKIPPED]: 0,
-            [StepStatusEnum.SUGGESTION]: 0,
-        }
-
-        public addSuggestion(text: string) {
-            this.push('Suggest', text, StepStatusEnum.SUGGESTION, 1000000);
-        }
-
-        public clear() {
-            this.stepLog = [];
-        }
-        
-        public push(keyword: string, name: string, status: StepStatusEnum, duration: number) {
-            console.log(`System log -- status: ${status} -- : ${name} `);
-            this.statusCounter[status] = this.statusCounter[status] + 1;
-            this.stepLog.push({ keyword: keyword, name: name, result: { status: status, duration: duration } });
-        }
-        
-        public returnScenarioReport() {
-            return this.stepLog;
-        }
-
-        public getStatusCount(status: StepStatusEnum): number{
-            return this.statusCounter[status];
-        }
+    public getStatusCount(status: StepStatusEnum): number {
+        return this.statusCounter[status];
     }
 }
 
-export default new Log.LogSteps();
+const log = new LogSteps();
+export default log;

package/src/auxta/services/report.service.ts

@@ -1,7 +1,7 @@
 import axios from "axios";
-import { Log } from "./log.service";
+import { Step } from "./log.service";
 import { config } from "../configs/config";
-import UploadModel from "../models/upload.model";
+import { UploadModel } from "../models/upload.model";
 
 export interface Feature {
     featureId: string,
@@ -62,7 +62,7 @@ export async function createEmptyReport(body: any): Promise<string> {
     )).data.reportId;
 }
 
-export async function uploadScenario(stepLog: Log.Step[], scenarioName: string, screenshot?: Buffer, errMessage?: string) {
+export async function uploadScenario(stepLog: Step[], scenarioName: string, screenshot?: Buffer, errMessage?: string) {
     let scenarios = [];
     let token = await auth();
     let lastStep = stepLog[stepLog.length - 1];

package/src/auxta/utilities/screenshot.helper.ts

@@ -1,7 +1,8 @@
-import { auxtaPuppeteer } from "../../AuxTA";
+import puppeteer  from "../../puppeteer/puppeteer";
 
 export async function captureScreenshot() {
-    const pages = await auxtaPuppeteer.defaultPage.browser().pages();
+    const pages = await puppeteer.defaultPage.browser().pages();
+    if (!pages.length) throw `Browser is closed`;
     const lastPage = pages[pages.length - 1];
 
     const screenshotBuffer = await lastPage.screenshot({
@@ -9,7 +10,7 @@ export async function captureScreenshot() {
             encoding: 'binary'
         }
     );
-    if (Buffer.isBuffer(screenshotBuffer)) 
+    if (Buffer.isBuffer(screenshotBuffer))
         return screenshotBuffer;
     else throw `Failed to capture buffer screenshot`;
 }

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

@@ -3,36 +3,64 @@ import puppeteer from "../../puppeteer/puppeteer";
 import { StepStatusEnum } from "../../auxta/enums/step-status.enum";
 
 export class FunctionHelper {
-    public readonly timeout: number = Number(process.env.AUXTA_TIMEOUT);
+    public readonly defaultTimeout: number = Number(process.env.AUXTA_TIMEOUT);
 
-    public async clickByText(selector: string, text: string, page = puppeteer.defaultPage) {
-        await page.waitForTimeout(this.timeout);
+    public log(keyword: string, name: string, status: StepStatusEnum){
+        log.push(keyword, name, status)
+    }
+
+    public suggest(name: string){
+        log.addSuggestion(name)
+    }
+
+    private getEscapedText(text: string){
         const splitedQuotes = text.replace(/'/g, `', "'", '`)
-        const escapedText = `concat('${splitedQuotes}', '')`;
-        const [linkHandlers] = await page.$x(`//${selector}[. = ${escapedText}]`);
+        return `concat('${splitedQuotes}', '')`;
+    }
+    
+    public async clickByText(selector: string, text: string, page = puppeteer.defaultPage) {
+        await page.waitForTimeout(this.defaultTimeout);
+        const [linkHandlers] = await page.$x(`//${selector}[. = ${this.getEscapedText(text)}]`);
 
         if (linkHandlers) {
-            log.push('And', `I click ${selector} with text ${text}`, StepStatusEnum.PASSED, 1000000);
+            log.push('And', `I click on the ${text} ${selector}`, StepStatusEnum.PASSED);
             await linkHandlers.click();
         } else {
-            log.push('And', `I click ${selector} with text ${text}`, StepStatusEnum.FAILED, 1000000);
+            log.push('And', `I click on the ${text} ${selector}`, StepStatusEnum.FAILED);
             throw new Error(`Link not found: ${text}`);
         }
     }
 
     public async waitForSelectorWithText(selector: string, text: string) {
-        const splitedQuotes = text.replace(/'/g, `', "'", '`)
-        const escapedText = `concat('${splitedQuotes}', '')`;
-        const linkHandlers = await puppeteer.defaultPage.$x(`//${selector}[. = ${escapedText}]`);
+        const linkHandlers = await puppeteer.defaultPage.$x(`//${selector}[. = ${this.getEscapedText(text)}]`);
         if (linkHandlers.length > 0) {
-            log.push('And', `I checked for ${text} and found it.`, StepStatusEnum.PASSED, 1000000);
+            log.push('And', `I checked for ${text} and found it.`, StepStatusEnum.PASSED);
             return true;
         } else {
-            log.push('And', `I checked for ${text} and found it.`, StepStatusEnum.FAILED, 1000000);
+            log.push('And', `I checked for ${text} and found it.`, StepStatusEnum.FAILED);
             throw new Error(`Link not found: ${text}`);
         }
     }
 
+    public async goto(page: string) {
+        await puppeteer.defaultPage.goto(page);
+        log.push('And', `I go to the ${page} page`, StepStatusEnum.PASSED);
+    }
+
+    public async type(field: string, value: string) {
+        await puppeteer.defaultPage.type(field, value);
+        const elementName = await puppeteer.defaultPage.$eval(field, (e) => e.textContent);
+        log.push('And', `I type '${value}' into the ${elementName} field`, StepStatusEnum.PASSED);
+    }
+
+    public async waitForNetwork() {
+        await puppeteer.defaultPage.waitForNetworkIdle();
+    }
+
+    public async timeout(timeout = this.defaultTimeout) {
+        await puppeteer.defaultPage.waitForTimeout(timeout);
+    }
+
     /**
      * Waiting for selector with timeout 60000
      *
@@ -43,7 +71,7 @@ export class FunctionHelper {
      * @param page
      */
 
-    public async waitForSelector(option: string, selector: string, time: number = this.timeout, page = puppeteer.defaultPage) {
+    public async waitForSelector(option: string, selector: string, time: number = this.defaultTimeout, page = puppeteer.defaultPage) {
         await page.waitForSelector(selector, {
             [option]: true,
             timeout: time
@@ -51,17 +79,19 @@ export class FunctionHelper {
     }
 
     public async click(className: string, page = puppeteer.defaultPage) {
-        await page.waitForTimeout(this.timeout);
+        await page.waitForTimeout(this.defaultTimeout);
         await page.click(className);
+        const elementName = await puppeteer.defaultPage.$eval(className, (e) => e.textContent);
+        log.push('Then', `I click on ${elementName}`, StepStatusEnum.PASSED);
     }
 
     public async urlContains(selector: string) {
         const url = puppeteer.defaultPage.url();
         if (!url.includes(selector)) {
-            await log.push('And', `I am on the ${selector} page`, StepStatusEnum.FAILED, 1000000);
+            log.push('And', `I am on the ${selector} page`, StepStatusEnum.FAILED);
             throw new Error(`I am not at the ${selector} page`)
         }
-        await log.push('And', `I am on the ${selector} page`, StepStatusEnum.PASSED, 1000000);
+        log.push('And', `I am on the ${selector} page`, StepStatusEnum.PASSED);
     }
 
 }

package/src/puppeteer/puppeteer.ts

@@ -1,12 +1,13 @@
 import chromium from 'chrome-aws-lambda';
 import log from "../auxta/services/log.service";
-import { returnImage } from '../auxta/helpers/response.helper';
 import { captureScreenshot } from "../auxta/utilities/screenshot.helper";
 import { AfterEach } from "../auxta/hooks/report.hook";
 import auxta from "../AuxTA";
 import { StepStatusEnum } from "../auxta/enums/step-status.enum";
 import { UploadModel } from "../auxta/models/upload.model";
 import puppeteer_core from 'puppeteer-core';
+import { config } from "./../auxta/configs/config";
+
 
 export class Puppeteer {
     public defaultPage!: puppeteer_core.Page;
@@ -22,26 +23,12 @@ export class Puppeteer {
                 '--disable-dev-shm-usage',
                 '--single-process'
             ],
-            defaultViewport: chromium.defaultViewport,
+            defaultViewport: null,
             // Return back to headless for commit
             headless: process.env.ENVIRONMENT == 'LOCAL' ? false : chromium.headless
         });
-        this.defaultPage = await this.browser.newPage();
-        await this.defaultPage.setViewport({
-            width: 1440,
-            height: 900
-        });
-    }
-
-    public async goto(page: string) {
-        await this.defaultPage.goto(page);
-    }
-
-    public async type(field: string, value: string) {
-        await this.defaultPage.type(field, value);
-    }
-
-    public async waitForNetwork() {
+        this.defaultPage = (await this.browser.pages())[0];
+        await this.defaultPage.goto(config.baseURL)
         await this.defaultPage.waitForNetworkIdle();
     }
 
@@ -53,7 +40,7 @@ export class Puppeteer {
         }
     }
 
-    public async run(event: any, callback: any, FeatureName = 'Test feature', ScenarioName = 'Test scenario', uploadModel?: UploadModel, close?: boolean) {
+    public async run(event: any, callback: any, featureName = 'Test feature', scenarioName = 'Test scenario', uploadModel?: UploadModel, close?: boolean) {
         if (uploadModel === undefined) uploadModel = auxta.getUploadModel();
         if (close === undefined) close = Puppeteer.setupHeader(event, uploadModel)
         let screenshotBuffer: Buffer;
@@ -61,23 +48,21 @@ export class Puppeteer {
         let statusCode: number = 200;
 
         try {
-            await log.push('When', `Starting puppeteer process`, StepStatusEnum.PASSED, 1000000);
+            await log.push('When', `Starting puppeteer process`, StepStatusEnum.PASSED);
             await this.startBrowser()
             await callback(event)
             screenshotBuffer = await captureScreenshot();
-            await log.push('When', `Finished puppeteer process`, StepStatusEnum.PASSED, 1000000);
+            await log.push('When', `Finished puppeteer process`, StepStatusEnum.PASSED);
         } catch (err: any) {
-            console.log(`This is an error ${err}`);
+            console.log(`Error ${err}`);
             errMessage = err;
             statusCode = 500;
             screenshotBuffer = await captureScreenshot();
-            await log.push('When', `Finished puppeteer process`, StepStatusEnum.FAILED, 1000000);
+            await log.push('When', `Finished puppeteer process`, StepStatusEnum.FAILED);
         }
         if (close) await this.close();
 
-        await AfterEach(uploadModel, FeatureName, ScenarioName, statusCode, screenshotBuffer, errMessage);
-
-        return returnImage(statusCode, screenshotBuffer);
+        await AfterEach(uploadModel, featureName, scenarioName, statusCode, screenshotBuffer, errMessage);
     }
 
     private static setupHeader(event: any, uploadModel: UploadModel) {

package/src/auxta/run.ts

@@ -1,14 +0,0 @@
-import { createEmptyReport } from "./services/report.service";
-import { startSuite } from "./utilities/start-suite.helper";
-import auxta from "../AuxTA";
-import { config } from "./configs/config";
-
-export default async function run(event: any) {
-    const model = auxta.getUploadModel();
-    let token: string = event.queryStringParameters.token;
-    let reportId: string | undefined = event.queryStringParameters.reportId;
-    if (token !== config.token) return {statusCode: 401, message: 'Unauthorized'}
-    const suites = config.suitesList.slice(0);
-    await startSuite(suites, reportId || await createEmptyReport(model));
-    return {statusCode: 204}
-}