@auxcode/auxta 0.1.3

package/README.md

@@ -0,0 +1,49 @@
+# AuxTA
+
+# Content
+* [puppeteer](#puppeteer)
+* [install](#install)
+* [setup](#setup)
+* [running](#running)
+
+## Puppeteer
+
+https://pptr.dev
+
+https://github.com/puppeteer/puppeteer
+
+## Install
+
+npm i
+
+## setup
+
+```
+{
+  # All background functions that will be run, listed
+  "suitesList": [
+    "{filename}-background"
+  ],
+  # The tested site's url
+  "baseURL": "https://{sitename}/",
+  # The url where the tests are ran
+  "testsURL": "https://{sitename}/",
+  # The organization's name
+  "organization": "string",
+  # The digital product's name
+  "digitalProduct": "bedrijfsfinanciering.com",
+  # Max timeout in milliseconds
+  # Default 1000
+  "timeout": 1000,
+  # The credentials of the user that uploads the tests to the site
+  "email": "",
+  "password": "",
+  "token": ""
+}
+
+```
+
+## running
+
+* Create a main function that calls the run() function which starts all tests
+* Create a function for each test that calls the `auxtaPuppeteer.run(event, callback, featureName, scenarioName)` function

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@auxcode/auxta",
+  "version": "0.1.3",
+  "description": "",
+  "main": "src/AuxTA.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run build & node ./build/AuxTA.js"
+  },
+  "author": "auxcode",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^0.24.0",
+    "chrome-aws-lambda": "^10.1.0",
+    "dotenv": "^10.0.0",
+    "chromium": "^3.0.3",
+    "puppeteer-core": "^10.0.0",
+    "typescript": "^4.5.2"
+  },
+  "devDependencies": {
+    "puppeteer": "^10.0.0",
+    "@babel/preset-typescript": "^7.16.0"
+  }
+}

package/src/AuxTA.ts

@@ -0,0 +1,60 @@
+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 { UploadModel } from "./auxta/models/upload.model";
+import * as dotenv from "dotenv";
+import { setupConfig } from "./auxta/configs/config";
+
+dotenv.config();
+
+class AuxTA {
+    public puppeteer: Puppeteer = puppeteer;
+    public func: FunctionHelper = f;
+    public run: Function = run;
+    public logger: Log.LogSteps = defaultLog;
+
+    private readonly uploadModel: UploadModel;
+
+    constructor() {
+        let file;
+        try {
+            //todo find a better way to load the file
+            file = path.join(__dirname, "../../../../../../", "suitesList.json");
+            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);
+            }
+            this.uploadModel = new UploadModel(jsonConfig.organization, jsonConfig.baseURL, jsonConfig.digitalProduct);
+        } catch (e) {
+            console.log("Missing or corrupted config: suitesList.json. Searching in location:", file)
+            console.log(e);
+            process.exit(1);
+        }
+    }
+
+    public getUploadModel(): UploadModel {
+        return this.uploadModel;
+    }
+}
+
+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/configs/config.ts

@@ -0,0 +1,35 @@
+export function setupConfig(jsonConfig: any) {
+    if (!jsonConfig.baseURL) throw new Error("baseURL");
+    config.baseURL = jsonConfig.baseURL;
+    if (!jsonConfig.digitalProduct) throw new Error("digitalProduct");
+    config.digitalProduct = jsonConfig.digitalProduct;
+    if (!jsonConfig.testsURL) throw new Error("testsURL");
+    config.netlifyPath = (process.env.ENVIRONMENT == 'LOCAL') ? 'http://localhost:9999/' : jsonConfig.testsURL;
+    if (!jsonConfig.organization) throw new Error("organization");
+    config.organization = jsonConfig.organization;
+    if (!jsonConfig.token) throw new Error("token");
+    config.token = jsonConfig.token;
+    if (!jsonConfig.email) throw new Error("email");
+    config.auxtaCredentials.email = jsonConfig.email;
+    if (!jsonConfig.password) throw new Error("password");
+    config.auxtaCredentials.password = jsonConfig.password;
+    if (!jsonConfig.suitesList) throw new Error("suitesList");
+    config.suitesList = jsonConfig.suitesList;
+    if (jsonConfig.timeout) config.timeout = jsonConfig.timeout;
+}
+
+export let config = {
+    auxtaURL: "https://auxta.live/.netlify/functions/",
+    baseURL: "",
+    siteURL: "",
+    organization: "",
+    netlifyPath: "",
+    digitalProduct: "",
+    token: "",
+    timeout: 1000,
+    suitesList: [],
+    auxtaCredentials: {
+        email: "",
+        password: "",
+    },
+}

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

@@ -0,0 +1,6 @@
+export enum StepStatusEnum {
+    PASSED = 'passed',
+    FAILED = 'failed',
+    SKIPPED = 'skipped',
+    SUGGESTION = 'suggestion',
+}

package/src/auxta/helpers/response.helper.ts

@@ -0,0 +1,11 @@
+export function returnImage(code: number, screenshot: Buffer) {
+    return {
+        isBase64Encoded: true,
+        statusCode: code,
+        headers: {
+            "Content-Type": "image/png",
+            "Content-Length": screenshot.length.toString()
+        },
+        body: screenshot.toString("base64")
+    };
+}

package/src/auxta/helpers/start.helper.ts

@@ -0,0 +1,14 @@
+import { join } from 'path';
+
+(async () => {
+    const r = /^--params\.suite=(.*)$/g;
+    let suite = process.argv.find(el => !!el.match(r));
+    if (!suite) throw `Locale is undefined`;
+    let suites = suite.replace('--params.suite=', '');
+    let suitesArr = suites.split(',');
+    if (!suitesArr) suitesArr = [ suites ];
+    for (const suite of suitesArr) {
+        let f = require(join(process.cwd(), 'build', 'functions', 'controllers',  suite));
+        await f.handler();
+    }
+})();

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

@@ -0,0 +1,61 @@
+import { basename } from 'path'
+import log from "../services/log.service";
+import {
+    Feature,
+    postNotifications,
+    Steps,
+    updateReport,
+    uploadFeature,
+    uploadScenario
+} from '../services/report.service';
+import { startSuite } from '../utilities/start-suite.helper';
+import { StepStatusEnum } from "../enums/step-status.enum";
+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;
+    if (process.env.ENVIRONMENT == "LIVE") {
+        console.log('asc ' + errMessage);
+        console.log('--- Uploading scenario and feature for AUXTA report ---');
+        const stepsArr = log.returnScenarioReport();
+        try {
+            const scenarioRes = await uploadScenario(stepsArr, scenarioName, screenshotBuffer, errMessage);
+            const featureRes = await uploadFeature(scenarioRes, featureName, basename(__filename), (statusCode != 200));
+            const feature: Feature = {
+                featureId: featureRes.featureRef,
+                featureName: featureRes.name,
+                featureUri: featureRes.uri,
+                status: featureRes.status,
+                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)
+            }
+            isFinal = (!(body.nextSuites && body.nextSuites.length > 0));
+            await updateReport(body.reportId, feature, stepCounts, isFinal);
+            console.log('--- Finished uploading report data to AUXTA ---');
+        } catch (error) {
+            console.log('--- Failed to update report in AUXTA ---')
+            console.log(error)
+        }
+    }
+    if (isFinal) await AfterComplete(body.reportId, body.endEmail, body);
+    else if (body && body.nextSuites && body.nextSuites.length > 0)
+        try {
+            await startSuite(body.nextSuites, body.reportId);
+        } catch {
+        }
+}
+
+export async function AfterComplete(reportId: string, endEmail: 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

@@ -0,0 +1,52 @@
+
+export class UploadModel {
+    private _reportId: string;
+    private _nextSuites: [];
+    private readonly _digitalProduct: string;
+    private readonly _baseUrl: string;
+    private readonly _organization: string;
+    private readonly _environment: string;
+
+    constructor(org: string, baseUrl: string, digitalProduct: string) {
+        this._reportId = '';
+        this._nextSuites = [];
+        this._organization = org;
+        this._digitalProduct = digitalProduct;
+        this._environment = process.env.NODE_ENV || "";
+        this._baseUrl = baseUrl;
+    }
+
+    get reportId(): string {
+        return this._reportId;
+    }
+
+    set reportId(value: string) {
+        this._reportId = value;
+    }
+
+    get nextSuites(): [] {
+        return this._nextSuites;
+    }
+
+    set nextSuites(value: []) {
+        this._nextSuites = value;
+    }
+
+    get digitalProduct(): string {
+        return this._digitalProduct;
+    }
+
+    get baseUrl(): string {
+        return this._baseUrl;
+    }
+
+    get organization(): string {
+        return this._organization;
+    }
+
+    get environment(): string {
+        return this._environment;
+    }
+}
+
+export default UploadModel;

package/src/auxta/run.ts

@@ -0,0 +1,14 @@
+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}
+}

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

@@ -0,0 +1,46 @@
+import { StepStatusEnum } from "../enums/step-status.enum";
+
+export namespace Log {
+    export interface Step {
+        keyword: string,
+        name: string,
+        result: {
+            status: StepStatusEnum,
+            duration: number
+        }
+    }
+
+    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];
+        }
+    }
+}
+
+export default new Log.LogSteps();

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

@@ -0,0 +1,174 @@
+import axios from "axios";
+import { Log } from "./log.service";
+import { config } from "../configs/config";
+import UploadModel from "../models/upload.model";
+
+export interface Feature {
+    featureId: string,
+    featureName: string,
+    featureUri: string,
+    status: string,
+    scenariosCount: number
+}
+
+export interface Scenario {
+    featureId: string,
+    featureName: string,
+    featureUri: string,
+    status: string,
+    scenariosCount: number
+}
+
+export interface Steps {
+    failedSteps: number,
+    passedSteps: number,
+    skippedSteps: number,
+    suggestedSteps: number
+}
+
+function headers(token: string) {
+    return {
+        headers: {
+            'Content-Type': 'application/json',
+            'cookie': `authToken=${token}`
+        }
+    }
+}
+
+async function auth() {
+    //todo what happens if credentials are invalid?
+    return (await axios.post(
+        config.auxtaURL + 'login',
+        config.auxtaCredentials,
+        {
+            headers: {
+                'Content-Type': 'application/json',
+            }
+        }
+    )).data.token;
+}
+
+export async function createEmptyReport(body: any): Promise<string> {
+    const token = await auth();
+    return (await axios.post(
+        config.auxtaURL + "create-empty-report",
+        {
+            environment: body.environment,
+            digitalProductName: body.digitalProduct,
+            start: new Date(),
+            url: body.baseUrl
+        },
+        headers(token)
+    )).data.reportId;
+}
+
+export async function uploadScenario(stepLog: Log.Step[], scenarioName: string, screenshot?: Buffer, errMessage?: string) {
+    let scenarios = [];
+    let token = await auth();
+    let lastStep = stepLog[stepLog.length - 1];
+    const stepLogFormat = JSON.parse(JSON.stringify(stepLog));
+    stepLogFormat.pop();
+    let output = (await axios.post(
+        config.auxtaURL + "create-scenario",
+        {
+            json: {
+                name: scenarioName,
+                steps: [
+                    ...stepLogFormat,
+                    (lastStep!.result.status == 'failed')
+                        ? Object.assign(lastStep, {
+                            result: {
+                                ...lastStep!.result,
+                                error_message: JSON.stringify(errMessage)
+                            }
+                        })
+                        : lastStep,
+                    {
+                        keyword: "After",
+                        result: {
+                            status: "passed",
+                            duration: 2678000000
+                        },
+                        embeddings: (screenshot) ? [{
+                            data: screenshot.toString("base64"),
+                            mime_type: "image/png"
+                        }] : undefined,
+                    }
+                ],
+            }
+        },
+        headers(token)
+    )).data.scenarios;
+    scenarios.push({
+        scenarioRef: output.scenarioRef,
+        name: output.name,
+        status: output.status,
+        stepsCount: output.stepsCount
+    });
+    return scenarios;
+}
+
+export async function uploadFeature(scenarioId: any[], scenarioName: string, uri: string, hasFailed: boolean) {
+    let token = await auth();
+    return (await axios.post(
+        config.auxtaURL + "create-feature",
+        {
+            json: {
+                name: scenarioName,
+                uri: uri
+            },
+            scenarios: scenarioId,
+            hasFailed: hasFailed
+        },
+        headers(token)
+    )).data;
+}
+
+export async function updateReport(reportId: string, feature: Feature, steps: Steps, isFinal: boolean) {
+    let token = await auth();
+    await axios.post(
+        config.auxtaURL + "update-inprogress-report",
+        {
+            reportId: reportId,
+            isFinal: isFinal,
+            data: {
+                feature: {
+                    featureRef: feature.featureId,
+                    name: feature.featureName,
+                    uri: feature.featureUri,
+                    status: feature.status,
+                    scenariosCount: feature.scenariosCount
+                },
+                ...steps
+            }
+        },
+        headers(token)
+    );
+}
+
+export async function getReport(reportId: string): Promise<any> {
+    let token = await auth();
+    return (await axios.post(
+        config.auxtaURL + "get-report",
+        {reportId: reportId},
+        headers(token)
+    )).data;
+}
+
+export async function getLastDayResults(): Promise<any> {
+    let token = await auth();
+    return (await axios.get(
+        config.auxtaURL + `get-last-day-results?url=${config.baseURL}`,
+        headers(token)
+    )).data.results;
+}
+
+export async function postNotifications(reportId: string, body: UploadModel) {
+    let token = await auth();
+    await axios.post(`${config.auxtaURL}post-notification-after-run-background`, {
+        environmentName: body.environment,
+        digitalProductName: body.digitalProduct,
+        organizationName: body.organization,
+        reportId: reportId,
+    }, headers(token));
+}

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

@@ -0,0 +1,51 @@
+export interface RunTime {
+    duration: String,
+    startTime: Date,
+    endTime: Date,
+}
+
+export class Runtime {
+    private start: Date;
+
+    private end: Date;
+
+    private runtime!: RunTime;
+
+    constructor(s: Date, e: Date) {
+        this.start = s;
+        this.end = e;
+    }
+
+    private calculateDuration() {
+        let currentTime = new Date;
+        let duration = currentTime.getTime() - this.start.getTime();
+        return duration;
+    }
+
+    private splitAtDecimanlMinutes(time: number) {
+        let minutes = time.toFixed(2).toString().split('.');
+        return `${minutes[0]}m ${(Number(minutes[1]) / 100 * 60).toFixed(0)}s`;
+    }
+
+    private splitAtDecimanlHours(time: number) {
+        let hours = time.toFixed(2).toString().split('.');
+        let minutes = (Number(hours[1]) / 100 * 60).toFixed(2).toString().split('.');
+        return `${hours[0]}h ${minutes[0]}m ${(Number(minutes[1]) / 100 * 60).toFixed(0)}s`;
+    }
+
+    private formatRuntime(duration: number) {
+        if(duration / 1000 < 60) return `${(duration / 1000).toFixed(0)}s`
+        else {
+            if(duration / 60000 < 60) return this.splitAtDecimanlMinutes(duration / 60000);
+            else return this.splitAtDecimanlHours(duration / 3600000);
+        }
+    }
+
+    public returnRuntime() : RunTime { 
+        let duration = this.formatRuntime(this.calculateDuration());
+        let startTime = this.start;
+        let endTime = this.end;
+        this.runtime = { duration, startTime, endTime }
+        return this.runtime;
+    }
+}

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

@@ -0,0 +1,29 @@
+import { RunTime } from "../services/runtime.service";
+
+export class CalculateRuntime {
+    private runtime: RunTime;
+    public startTimeSeconds: string;
+    public startTimeMinutes: string;
+    public startTimeHours: string;
+    public startTimeDay: string;
+    public startTimeMonth: string;
+    public endTimeSeconds: string;
+    public endTimeMinutes: string;
+    public endTimeHours: string;
+    public endTimeDay: string;
+    public endTimeMonth: string;
+    constructor(r: RunTime){
+        this.runtime = r;
+        this.startTimeSeconds = (this.runtime.startTime.getSeconds() < 10) ? `0${this.runtime.startTime.getSeconds()}` : `${this.runtime.startTime.getSeconds()}`
+        this.startTimeMinutes = (this.runtime.startTime.getMinutes() < 10) ? `0${this.runtime.startTime.getMinutes()}` : `${this.runtime.startTime.getMinutes()}`;
+        this.startTimeHours = (this.runtime.startTime.getHours() < 10) ? `0${this.runtime.startTime.getHours()}` : `${this.runtime.startTime.getHours()}`;
+        this.startTimeDay = (this.runtime.startTime.getDate() < 10) ? `0${this.runtime.startTime.getDate()}` : `${this.runtime.startTime.getDate()}`;
+        this.startTimeMonth = (this.runtime.startTime.getMonth() + 1 < 10) ? `0${this.runtime.startTime.getMonth() + 1}` : `${this.runtime.startTime.getMonth() + 1}`;
+
+        this.endTimeSeconds = (this.runtime.endTime.getSeconds() < 10) ? `0${this.runtime.endTime.getSeconds()}` : `${this.runtime.endTime.getSeconds()}`;
+        this.endTimeMinutes = (this.runtime.endTime.getMinutes() < 10) ? `0${this.runtime.endTime.getMinutes()}` : `${this.runtime.endTime.getMinutes()}`;
+        this.endTimeHours = (this.runtime.endTime.getHours() < 10) ? `0${this.runtime.endTime.getHours()}` : `${this.runtime.endTime.getHours()}`;
+        this.endTimeDay = (this.runtime.endTime.getDate() < 10) ? `0${this.runtime.endTime.getDate()}` : `${this.runtime.endTime.getDate()}`;
+        this.endTimeMonth = (this.runtime.endTime.getMonth() + 1 < 10) ? `0${this.runtime.endTime.getMonth() + 1}` : `${this.runtime.endTime.getMonth() + 1}`;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { auxtaPuppeteer } from "../../AuxTA";
+
+export async function captureScreenshot() {
+    const pages = await auxtaPuppeteer.defaultPage.browser().pages();
+    const lastPage = pages[pages.length - 1];
+
+    const screenshotBuffer = await lastPage.screenshot({
+            fullPage: true,
+            encoding: 'binary'
+        }
+    );
+    if (Buffer.isBuffer(screenshotBuffer)) 
+        return screenshotBuffer;
+    else throw `Failed to capture buffer screenshot`;
+}

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

@@ -0,0 +1,11 @@
+import axios from 'axios';
+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()}`,
+        { nextSuites: suites, reportId: reportId}
+    );
+}

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

@@ -0,0 +1,69 @@
+import log from "../../auxta/services/log.service";
+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 async clickByText(selector: string, text: string, page = puppeteer.defaultPage) {
+        await page.waitForTimeout(this.timeout);
+        const splitedQuotes = text.replace(/'/g, `', "'", '`)
+        const escapedText = `concat('${splitedQuotes}', '')`;
+        const [linkHandlers] = await page.$x(`//${selector}[. = ${escapedText}]`);
+
+        if (linkHandlers) {
+            log.push('And', `I click ${selector} with text ${text}`, StepStatusEnum.PASSED, 1000000);
+            await linkHandlers.click();
+        } else {
+            log.push('And', `I click ${selector} with text ${text}`, StepStatusEnum.FAILED, 1000000);
+            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}]`);
+        if (linkHandlers.length > 0) {
+            log.push('And', `I checked for ${text} and found it.`, StepStatusEnum.PASSED, 1000000);
+            return true;
+        } else {
+            log.push('And', `I checked for ${text} and found it.`, StepStatusEnum.FAILED, 1000000);
+            throw new Error(`Link not found: ${text}`);
+        }
+    }
+
+    /**
+     * Waiting for selector with timeout 60000
+     *
+     * @function waitForSelector
+     * @param {string} option - visible, hidden
+     * @param selector - class to select
+     * @param time
+     * @param page
+     */
+
+    public async waitForSelector(option: string, selector: string, time: number = this.timeout, page = puppeteer.defaultPage) {
+        await page.waitForSelector(selector, {
+            [option]: true,
+            timeout: time
+        });
+    }
+
+    public async click(className: string, page = puppeteer.defaultPage) {
+        await page.waitForTimeout(this.timeout);
+        await page.click(className);
+    }
+
+    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);
+            throw new Error(`I am not at the ${selector} page`)
+        }
+        await log.push('And', `I am on the ${selector} page`, StepStatusEnum.PASSED, 1000000);
+    }
+
+}
+
+export default new FunctionHelper();

package/src/puppeteer/puppeteer.ts

@@ -0,0 +1,96 @@
+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';
+
+export class Puppeteer {
+    public defaultPage!: puppeteer_core.Page;
+    private browser!: puppeteer_core.Browser;
+
+    public async startBrowser() {
+        this.browser = await chromium.puppeteer.launch({
+            executablePath: process.env.NODE_ENV !== 'production' ? undefined : await chromium.executablePath,
+            args: [
+                '--start-maximized',
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--single-process'
+            ],
+            defaultViewport: chromium.defaultViewport,
+            // 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() {
+        await this.defaultPage.waitForNetworkIdle();
+    }
+
+    public async close() {
+        if (this.browser) {
+            let pages = await this.browser.pages();
+            await Promise.all(pages.map((page: { close: () => any; }) => page.close()));
+            await this.browser.close();
+        }
+    }
+
+    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;
+        let errMessage: string | undefined;
+        let statusCode: number = 200;
+
+        try {
+            await log.push('When', `Starting puppeteer process`, StepStatusEnum.PASSED, 1000000);
+            await this.startBrowser()
+            await callback(event)
+            screenshotBuffer = await captureScreenshot();
+            await log.push('When', `Finished puppeteer process`, StepStatusEnum.PASSED, 1000000);
+        } catch (err: any) {
+            console.log(`This is an error ${err}`);
+            errMessage = err;
+            statusCode = 500;
+            screenshotBuffer = await captureScreenshot();
+            await log.push('When', `Finished puppeteer process`, StepStatusEnum.FAILED, 1000000);
+        }
+        if (close) await this.close();
+
+        await AfterEach(uploadModel, FeatureName, ScenarioName, statusCode, screenshotBuffer, errMessage);
+
+        return returnImage(statusCode, screenshotBuffer);
+    }
+
+    private static setupHeader(event: any, uploadModel: UploadModel) {
+        let close = true;
+        if (process.env.ENVIRONMENT !== 'LOCAL') {
+            const body = JSON.parse(event.body);
+            uploadModel.reportId = body.reportId;
+            uploadModel.nextSuites = body.nextSuites;
+        } else if (event.queryStringParameters.close) {
+            close = event.queryStringParameters.close === "true";
+        }
+        return close;
+    }
+}
+
+export default new Puppeteer();

package/tsconfig.json

@@ -0,0 +1,65 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "incremental": true, /* Enable incremental compilation */
+    "target": "ES2020", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    "sourceMap": false, /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    "outDir": "./build", /* Redirect output structure to the directory. */
+    "rootDir": "./src", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    "removeComments": true, /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+    /* Strict Type-Checking Options */
+    "strict": true, /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+    /* Additional Checks */
+    "noUnusedLocals": true, /* Report errors on unused locals. */
+    "noUnusedParameters": false, /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+    /* Module Resolution Options */
+    "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    "baseUrl": "./", /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    "typeRoots": [ "./node_modules/@types" ],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true, /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+    /* Experimental Options */
+    "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */
+    "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */
+    /* Advanced Options */
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "exclude": [
+    "node_modules", "build", "public", "content"
+  ]
+}