@auxcode/auxta 0.2.3 → 0.2.4

package/package.json

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

package/src/AuxTA.ts

@@ -2,10 +2,10 @@ import puppeteer, { Puppeteer } from "./puppeteer/puppeteer";
 import { FunctionHelper } from "./macros/helpers/code.helper";
 import path from "path";
 import fs from "fs";
-import StepStatusEnum from "./auxta/enums/step-status.enum";
+import StatusOfStep from "./auxta/enums/status-of.step";
 import { UploadModel } from "./auxta/models/upload.model";
 import * as dotenv from "dotenv";
-import { config, setupConfig } from "./auxta/configs/config";
+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";
 
@@ -13,6 +13,7 @@ dotenv.config();
 
 class AuxTA extends FunctionHelper {
     public puppeteer: Puppeteer = puppeteer;
+    public config = c;
 
     private readonly uploadModel: UploadModel;
 
@@ -36,7 +37,7 @@ class AuxTA extends FunctionHelper {
             }
             const jsonConfig = JSON.parse(fs.readFileSync(file).toString());
             try {
-                setupConfig(jsonConfig)
+                this.config = setupConfig(jsonConfig)
             } catch (e: any) {
                 console.log("Missing field in auxta.json:", e.message)
             }
@@ -48,18 +49,33 @@ class AuxTA extends FunctionHelper {
         }
     }
 
-    public async run(event: any) {
-        const model = this.uploadModel;
-        let token: string = event.queryStringParameters.token;
+    public async run(event: any, overrideConfig?: any) {
+        this.changeModelData(overrideConfig);
         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));
+        if (process.env.ENVIRONMENT === 'LIVE' && event.queryStringParameters.token !== this.config.token)
+            return {statusCode: 401, message: 'Unauthorized'}
+        const suites = this.config.suitesList.slice(0);
+        await startSuite(suites, reportId || await createEmptyReport(this.uploadModel));
         return {statusCode: 204}
     }
+    private changeModelData(overrideConfig?: any){
+        if (overrideConfig) {
+            if (overrideConfig.digitalProduct) this.uploadModel.digitalProduct = overrideConfig.digitalProduct
+            if (overrideConfig.environment) this.uploadModel.environment = overrideConfig.environment
+            if (overrideConfig.baseUrl) this.uploadModel.baseUrl = overrideConfig.baseUrl
+            this.config = setupOverrideConfig(overrideConfig)
+        }
+    }
 
-    public startBrowser(event: any, callback: any, feature: string, scenario: string) {
-        this.puppeteer.run(event, callback, feature, scenario)
+    public async startBrowser(event: any, callback: any, feature: string, scenario: string, overrideConfig?: any, singleFeature = false) {
+        this.changeModelData(overrideConfig);
+        if (singleFeature) {
+            if (process.env.ENVIRONMENT === 'LIVE' && event.queryStringParameters.token !== this.config.token)
+                return {statusCode: 401, message: 'Unauthorized'}
+            this.uploadModel.reportId = await createEmptyReport(this.uploadModel);
+            this.uploadModel.nextSuites = [];
+        }
+        return this.puppeteer.run(event, callback, feature, scenario)
     }
 
     public getUploadModel(): UploadModel {
@@ -67,7 +83,7 @@ class AuxTA extends FunctionHelper {
     }
 }
 
-export const StepStatus = StepStatusEnum;
+export const StepStatus = StatusOfStep;
 
 const auxta: AuxTA = new AuxTA();
 

package/src/auxta/configs/config.ts

@@ -18,6 +18,13 @@ export function setupConfig(jsonConfig: any) {
     if (jsonConfig.timeout) config.timeout = jsonConfig.timeout;
     if (jsonConfig.screenWidth) config.screenWidth = jsonConfig.screenWidth;
     if (jsonConfig.screenHeight) config.screenHeight = jsonConfig.screenHeight;
+    return config;
+}
+
+export function setupOverrideConfig(overrideConfig: any){
+    if (overrideConfig.baseURL) config.baseURL = overrideConfig.baseURL;
+    if (overrideConfig.digitalProduct) config.digitalProduct = overrideConfig.digitalProduct;
+    return config;
 }
 
 export let config = {

package/src/auxta/enums/{step-status.enum.ts → status-of.step.ts}

@@ -1,7 +1,7 @@
-export enum StepStatusEnum {
+export enum StatusOfStep {
     PASSED = 'passed',
     FAILED = 'failed',
     SKIPPED = 'skipped',
     SUGGESTION = 'suggestion',
 }
-export default StepStatusEnum;
+export default StatusOfStep;

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

@@ -9,7 +9,7 @@ import {
     uploadScenario
 } from '../services/report.service';
 import { startSuite } from '../utilities/start-suite.helper';
-import { StepStatusEnum } from "../enums/step-status.enum";
+import { StatusOfStep } from "../enums/status-of.step";
 import { UploadModel } from "../models/upload.model";
 
 export async function onTestEnd(body: any, featureName: string, scenarioName: string, statusCode: number, screenshotBuffer: Buffer, errMessage?: object) {
@@ -29,10 +29,10 @@ export async function onTestEnd(body: any, featureName: string, scenarioName: st
                 scenariosCount: featureRes.scenariosCount
             }
             const stepCounts: Steps = {
-                failedSteps: log.getStatusCount(StepStatusEnum.FAILED),
-                passedSteps: log.getStatusCount(StepStatusEnum.PASSED),
-                skippedSteps: log.getStatusCount(StepStatusEnum.SKIPPED),
-                suggestedSteps: log.getStatusCount(StepStatusEnum.SUGGESTION)
+                failedSteps: log.getStatusCount(StatusOfStep.FAILED),
+                passedSteps: log.getStatusCount(StatusOfStep.PASSED),
+                skippedSteps: log.getStatusCount(StatusOfStep.SKIPPED),
+                suggestedSteps: log.getStatusCount(StatusOfStep.SUGGESTION)
             }
             isFinal = (!(body.nextSuites && body.nextSuites.length > 0));
             await updateReport(body.reportId, feature, stepCounts, isFinal);
@@ -42,20 +42,15 @@ export async function onTestEnd(body: any, featureName: string, scenarioName: st
             console.log(error)
         }
     }
-    if (isFinal) await AfterComplete(body.reportId, body.endEmail, body);
-    else if (body && body.nextSuites && body.nextSuites.length > 0)
+    if (isFinal) await afterComplete(body.reportId, body);
+    else if (body && body.nextSuites && body.nextSuites[0])
         try {
             await startSuite(body.nextSuites, body.reportId);
         } catch {
         }
 }
 
-export async function AfterComplete(reportId: string, endEmail: string, body: UploadModel) {
-    if (process.env.ENVIRONMENT == "LIVE") {
+export async function afterComplete(reportId: string, body: UploadModel) {
+    if (process.env.ENVIRONMENT == "LIVE")
         await postNotifications(reportId, body);
-    }
-}
-
-export function sleep(ms: number) {
-    return new Promise(resolve => setTimeout(resolve, ms));
 }

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

@@ -2,10 +2,10 @@
 export class UploadModel {
     private _reportId: string;
     private _nextSuites: [];
-    private readonly _digitalProduct: string;
-    private readonly _baseUrl: string;
+    private _digitalProduct: string;
+    private _baseUrl: string;
     private readonly _organization: string;
-    private readonly _environment: string;
+    private _environment: string;
 
     constructor(org: string, baseUrl: string, digitalProduct: string) {
         this._reportId = '';
@@ -36,15 +36,27 @@ export class UploadModel {
         return this._digitalProduct;
     }
 
-    get baseUrl(): string {
-        return this._baseUrl;
+    set digitalProduct(value: string) {
+        this._digitalProduct = value;
     }
 
     get organization(): string {
         return this._organization;
     }
 
+    get baseUrl(): string {
+        return this._baseUrl;
+    }
+
+    set baseUrl(value: string) {
+        this._baseUrl = value;
+    }
+
     get environment(): string {
         return this._environment;
     }
+
+    set environment(value: string) {
+        this._environment = value;
+    }
 }

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

@@ -1,10 +1,10 @@
-import { StepStatusEnum } from "../enums/step-status.enum";
+import { StatusOfStep } from "../enums/status-of.step";
 
 export interface Step {
     keyword: string,
     name: string,
     result: {
-        status: StepStatusEnum,
+        status: StatusOfStep,
         duration: number
     }
 }
@@ -13,17 +13,17 @@ 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,
+        [StatusOfStep.PASSED]: 0,
+        [StatusOfStep.FAILED]: 0,
+        [StatusOfStep.SKIPPED]: 0,
+        [StatusOfStep.SUGGESTION]: 0,
     }
 
     public addSuggestion(text: string) {
-        this.statusCounter[StepStatusEnum.SUGGESTION]++;
+        this.statusCounter[StatusOfStep.SUGGESTION]++;
         this.stepLog.push({
             keyword: 'Suggestion', name: text, result:
-                {status: StepStatusEnum.SUGGESTION, duration: 0}
+                {status: StatusOfStep.SUGGESTION, duration: 0}
         });
     }
 
@@ -31,7 +31,7 @@ export class LogSteps {
         this.stepLog = [];
     }
 
-    public push(keyword: string, name: string, status: StepStatusEnum) {
+    public push(keyword: string, name: string, status: StatusOfStep) {
         console.log(`System log -- status: ${status} -- : ${name} `);
         this.statusCounter[status]++;
         const currentStep = new Date().getTime();
@@ -43,7 +43,7 @@ export class LogSteps {
         return this.stepLog;
     }
 
-    public getStatusCount(status: StepStatusEnum): number {
+    public getStatusCount(status: StatusOfStep): number {
         return this.statusCounter[status];
     }
 }

package/src/auxta/utilities/start-suite.helper.ts

@@ -3,9 +3,8 @@ import { config } from "../configs/config";
 
 export function startSuite(suites: string[], reportId?: string) {
     console.log('Starting next suite: ' + suites[0]);
-    console.log(suites,reportId);
     return axios.post(
-        `${config.netlifyPath}.netlify/functions/${suites.shift()}`,
+        `${config.netlifyPath}.netlify/functions/${suites.shift()}?token=${config.token}`,
         { nextSuites: suites, reportId: reportId}
     );
 }

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

@@ -1,12 +1,12 @@
 import log from "../../auxta/services/log.service";
 import puppeteer from "../../puppeteer/puppeteer";
-import { StepStatusEnum } from "../../auxta/enums/step-status.enum";
+import { StatusOfStep } from "../../auxta/enums/status-of.step";
 import { config } from "../../auxta/configs/config";
 
 export class FunctionHelper {
     public readonly defaultTimeout: number = config.timeout;
 
-    public log(keyword: string, name: string, status: StepStatusEnum){
+    public log(keyword: string, name: string, status: StatusOfStep){
         log.push(keyword, name, status)
     }
 
@@ -25,51 +25,51 @@ export class FunctionHelper {
 
         const message = `I click on the ${text} ${selector}`;
         if (linkHandlers) {
-            log.push('Then', message, StepStatusEnum.PASSED);
+            log.push('Then', message, StatusOfStep.PASSED);
             await linkHandlers.click();
         } else {
-            log.push('Then', message, StepStatusEnum.FAILED);
+            log.push('Then', message, StatusOfStep.FAILED);
             throw new Error(`Link not found: ${text}`);
         }
     }
 
-    public async waitForSelectorWithText(selector: string, text: string) {
-        const linkHandlers = await puppeteer.defaultPage.$x(`//${selector}[. = ${this.getEscapedText(text)}]`);
+    public async waitForSelectorWithText(selector: string, text: string, page = puppeteer.defaultPage) {
+        const linkHandlers = await page.$x(`//${selector}[. = ${this.getEscapedText(text)}]`);
         const message = `I check for ${text}`;
         if (linkHandlers.length > 0) {
-            log.push('And', message, StepStatusEnum.PASSED);
+            log.push('And', message, StatusOfStep.PASSED);
             return true;
         } else {
-            log.push('And', message, StepStatusEnum.FAILED);
+            log.push('And', message, StatusOfStep.FAILED);
             throw new Error(`Link not found: ${text}`);
         }
     }
 
-    public async goto(page: string) {
-        await puppeteer.defaultPage.goto(page);
-        log.push('Then', `I go to the ${page} page`, StepStatusEnum.PASSED);
+    public async goto(url: string, page = puppeteer.defaultPage) {
+        await page.goto(url);
+        log.push('Then', `I go to the ${url} page`, StatusOfStep.PASSED);
     }
 
-    public async type(field: string, value: string) {
-        await puppeteer.defaultPage.type(field, value);
-        let elementName = await puppeteer.defaultPage.$eval(field, (e) => e.textContent);
+    public async type(field: string, value: string, page = puppeteer.defaultPage) {
+        await page.type(field, value);
+        let elementName = await page.$eval(field, (e) => e.textContent);
         if (!elementName || elementName === ' ') elementName = field;
-        log.push('Then', `I type '${value}' into the ${elementName} field`, StepStatusEnum.PASSED);
+        log.push('Then', `I type '${value}' into the ${elementName} field`, StatusOfStep.PASSED);
     }
 
-    public async waitForNetwork() {
+    public async waitForNetwork(page = puppeteer.defaultPage) {
         let message = 'I wait for the page to load'
         try{
-            await puppeteer.defaultPage.waitForNetworkIdle();
-            log.push('Then', message, StepStatusEnum.PASSED);
+            await page.waitForNetworkIdle();
+            log.push('Then', message, StatusOfStep.PASSED);
         } catch (e){
-            log.push('Then', message, StepStatusEnum.FAILED);
+            log.push('Then', message, StatusOfStep.FAILED);
             throw new Error(message)
         }
     }
 
-    public async timeout(timeout = this.defaultTimeout) {
-        await puppeteer.defaultPage.waitForTimeout(timeout);
+    public async timeout(timeout = this.defaultTimeout, page = puppeteer.defaultPage) {
+        await page.waitForTimeout(timeout);
     }
 
     /**
@@ -90,10 +90,10 @@ export class FunctionHelper {
                 timeout: time
             });
         } catch (e){
-            log.push('And', message, StepStatusEnum.FAILED);
+            log.push('And', message, StatusOfStep.FAILED);
             throw new Error(message)
         }
-        log.push('And', message, StepStatusEnum.PASSED);
+        log.push('And', message, StatusOfStep.PASSED);
     }
 
     public async click(className: string, page = puppeteer.defaultPage) {
@@ -101,17 +101,17 @@ export class FunctionHelper {
         let elementName = await puppeteer.defaultPage.$eval(className, (e) => e.textContent);
         if (!elementName || elementName === ' ') elementName = className;
         await page.click(className);
-        log.push('Then', `I click on ${elementName}`, StepStatusEnum.PASSED);
+        log.push('Then', `I click on ${elementName}`, StatusOfStep.PASSED);
     }
 
     public async urlContains(selector: string) {
         const url = puppeteer.defaultPage.url();
         let message = `I am on the ${selector} page`
         if (!url.includes(selector)) {
-            log.push('And', message, StepStatusEnum.FAILED);
+            log.push('And', message, StatusOfStep.FAILED);
             throw new Error(`I am not at the ${selector} page`)
         }
-        log.push('And', message, StepStatusEnum.PASSED);
+        log.push('And', message, StatusOfStep.PASSED);
     }
 
 }

package/src/puppeteer/puppeteer.ts

@@ -3,7 +3,7 @@ import log from "../auxta/services/log.service";
 import { captureScreenshot } from "../auxta/utilities/screenshot.helper";
 import { onTestEnd } from "../auxta/hooks/report.hook";
 import auxta from "../AuxTA";
-import { StepStatusEnum } from "../auxta/enums/step-status.enum";
+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";
@@ -34,7 +34,7 @@ export class Puppeteer {
             headless: process.env.ENVIRONMENT == 'LOCAL' ? false : chromium.headless
         });
         this.defaultPage = (await this.browser.pages())[0];
-        await this.defaultPage.goto(config.baseURL)
+        await this.defaultPage.goto(config.baseURL, {waitUntil: 'networkidle0'})
         await this.defaultPage.waitForNetworkIdle();
     }
 
@@ -53,32 +53,33 @@ export class Puppeteer {
         let errMessage: string | undefined;
         let statusCode: number = 200;
 
-        let consoleStack = [];
+        let consoleStack: any[] = [];
         try {
-            await log.push('When', `Starting puppeteer process`, StepStatusEnum.PASSED);
+            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('pageerror', ({message}) => consoleStack.push(message))
                 .on('response', response =>
                     consoleStack.push(`${response.status()} ${response.url()}`))
                 .on('requestfailed', request =>
                     consoleStack.push(`${request.failure().errorText} ${request.url()}`))
             await callback(event)
             screenshotBuffer = await captureScreenshot();
-            await log.push('When', `Finished puppeteer process`, StepStatusEnum.PASSED);
+            await log.push('When', `Finished puppeteer process`, StatusOfStep.PASSED);
         } catch (err: any) {
             console.log(`Error ${err}`);
             errMessage = err;
             statusCode = 500;
             screenshotBuffer = await captureScreenshot();
-            await log.push('When', `Finished puppeteer process`, StepStatusEnum.FAILED);
+            await log.push('When', `Finished puppeteer process`, StatusOfStep.FAILED);
         }
         let url = this.defaultPage.url();
         if (close) await this.close();
 
         await onTestEnd(uploadModel, featureName, scenarioName, statusCode, screenshotBuffer, !errMessage ? undefined : {
             currentPageUrl: url,
+            console: consoleStack,
             error: errMessage
         });
         log.clear();