@auxcode/auxta 1.3.132 → 1.3.133

package/build/auxta/services/log.service.d.ts

@@ -0,0 +1,39 @@
+import { StatusOfStep } from "../enums/status-of.step";
+export interface Step {
+    keyword: string;
+    tag: string;
+    name: string;
+    imageCompareKey: string;
+    result: {
+        status: StatusOfStep;
+        duration: number;
+        embedding?: {
+            data: Uint8Array | Buffer;
+            mime_type: string;
+        };
+    };
+}
+export declare class LogSteps {
+    statusCounter: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        suggestion: number;
+        performanceFailure: number;
+        log: number;
+    };
+    private stepLog;
+    private lastStepTime;
+    private _tags;
+    addSuggestion(text: string): void;
+    addPerformanceFail(text: string, screenshot?: Uint8Array | Buffer): void;
+    clear(): void;
+    push(keyword: string, tag: string, name: string, status: StatusOfStep, screenshot?: Uint8Array | Buffer, imageCompareKey?: string): void;
+    returnScenarioReport(): Step[];
+    getStatusCount(status: StatusOfStep): number;
+    get tag(): string;
+    set tag(value: string);
+    clearTag(): void;
+}
+declare const log: LogSteps;
+export default log;

package/build/auxta/services/log.service.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogSteps = void 0;
+const status_of_step_1 = require("../enums/status-of.step");
+class LogSteps {
+    constructor() {
+        this.statusCounter = {
+            [status_of_step_1.StatusOfStep.PASSED]: 0,
+            [status_of_step_1.StatusOfStep.FAILED]: 0,
+            [status_of_step_1.StatusOfStep.SKIPPED]: 0,
+            [status_of_step_1.StatusOfStep.SUGGESTION]: 0,
+            [status_of_step_1.StatusOfStep.PERFORMANCE_FAIL]: 0,
+            [status_of_step_1.StatusOfStep.LOG]: 0
+        };
+        this.stepLog = [];
+        this.lastStepTime = new Date().getTime();
+        this._tags = ['default'];
+    }
+    addSuggestion(text) {
+        this.statusCounter[status_of_step_1.StatusOfStep.SUGGESTION]++;
+        this.stepLog.push({
+            keyword: 'Suggestion', tag: this.tag, name: text, imageCompareKey: '', result: { status: status_of_step_1.StatusOfStep.SUGGESTION, duration: 0 }
+        });
+    }
+    addPerformanceFail(text, screenshot = new Uint8Array()) {
+        this.statusCounter[status_of_step_1.StatusOfStep.PERFORMANCE_FAIL]++;
+        const currentStep = new Date().getTime();
+        if (screenshot.byteLength != 0) {
+            const embedding = {
+                data: screenshot,
+                mime_type: "image/png"
+            };
+            this.stepLog.push({
+                keyword: 'PerformanceFail',
+                tag: this.tag,
+                name: text,
+                imageCompareKey: '',
+                result: { status: status_of_step_1.StatusOfStep.PERFORMANCE_FAIL, duration: currentStep - this.lastStepTime, embedding }
+            });
+        }
+        else {
+            this.stepLog.push({
+                keyword: 'PerformanceFail',
+                tag: this.tag,
+                name: text,
+                imageCompareKey: '',
+                result: { status: status_of_step_1.StatusOfStep.PERFORMANCE_FAIL, duration: currentStep - this.lastStepTime }
+            });
+        }
+        this.lastStepTime = currentStep;
+    }
+    clear() {
+        this.stepLog = [];
+        this.statusCounter = {
+            [status_of_step_1.StatusOfStep.PASSED]: 0,
+            [status_of_step_1.StatusOfStep.FAILED]: 0,
+            [status_of_step_1.StatusOfStep.SKIPPED]: 0,
+            [status_of_step_1.StatusOfStep.SUGGESTION]: 0,
+            [status_of_step_1.StatusOfStep.PERFORMANCE_FAIL]: 0,
+            [status_of_step_1.StatusOfStep.LOG]: 0
+        };
+    }
+    push(keyword, tag, name, status, screenshot = new Uint8Array(), imageCompareKey = '') {
+        console.log(`System log -- status: ${status} -- tag: ${tag} -- : ${name} `);
+        this.statusCounter[status]++;
+        const currentStep = new Date().getTime();
+        if (screenshot.byteLength != 0) {
+            const embedding = {
+                data: screenshot,
+                mime_type: "image/png"
+            };
+            this.stepLog.push({
+                keyword,
+                tag,
+                name,
+                imageCompareKey,
+                result: { status, duration: currentStep - this.lastStepTime, embedding }
+            });
+        }
+        else {
+            this.stepLog.push({
+                keyword,
+                tag,
+                name,
+                imageCompareKey,
+                result: { status, duration: currentStep - this.lastStepTime }
+            });
+        }
+        this.lastStepTime = currentStep;
+    }
+    returnScenarioReport() {
+        return this.stepLog;
+    }
+    getStatusCount(status) {
+        return this.statusCounter[status];
+    }
+    get tag() {
+        return this._tags.length === 1 ? this._tags[0] : this._tags[1];
+    }
+    set tag(value) {
+        this._tags.push(value);
+    }
+    clearTag() {
+        this._tags.pop();
+    }
+}
+exports.LogSteps = LogSteps;
+const log = new LogSteps();
+exports.default = log;

package/build/auxta/services/report.service.d.ts

@@ -0,0 +1,41 @@
+import { Step } from "./log.service";
+import { UploadModel } from "../models/upload.model";
+export interface Scenarios {
+    scenarioId: string;
+    scenarioName: string;
+    scenarioUri: string;
+    status: string;
+    scenariosCount: number;
+    lastTag: string;
+}
+export interface Steps {
+    failedSteps: number;
+    passedSteps: number;
+    skippedSteps: number;
+    suggestedSteps: number;
+    performanceFailure: number;
+    log: number;
+}
+export declare function setTimeZone(): Promise<any>;
+export declare function setEmailProvider(): Promise<any>;
+export declare function createEmptyReport(body: any): Promise<string>;
+export declare function uploadStep(stepLog: Step[], scenarioName: string, screenshot?: Buffer, errMessage?: object): Promise<{
+    stepRef: any;
+    name: any;
+    status: any;
+    stepsCount: any;
+}[]>;
+export declare function uploadScenario(stepRes: any[], scenarioName: string, uri: string, hasFailed: boolean): Promise<any>;
+export declare function updateReport(reportId: string, scenario: Scenarios, steps: Steps, isFinal: boolean): Promise<void>;
+export declare function getReport(reportId: string): Promise<any>;
+export declare function getLastDayResults(): Promise<any>;
+export declare function compareScreenshots(key: string, screenshot?: Uint8Array | Buffer): Promise<any>;
+export declare function postNotifications(body: UploadModel): Promise<void>;
+export declare function postNotificationsOnFail(body: UploadModel): Promise<void>;
+export declare function getVerifyReceivedEmail(from_name: string, from_email: string, subject: string, body: string, link: boolean): Promise<import("axios").AxiosResponse<any, {
+    from_name: string;
+    from_email: string;
+    subject: string;
+    body: string;
+    link: boolean;
+}, {}, any>>;

package/build/auxta/services/report.service.js

@@ -0,0 +1,269 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTimeZone = setTimeZone;
+exports.setEmailProvider = setEmailProvider;
+exports.createEmptyReport = createEmptyReport;
+exports.uploadStep = uploadStep;
+exports.uploadScenario = uploadScenario;
+exports.updateReport = updateReport;
+exports.getReport = getReport;
+exports.getLastDayResults = getLastDayResults;
+exports.compareScreenshots = compareScreenshots;
+exports.postNotifications = postNotifications;
+exports.postNotificationsOnFail = postNotificationsOnFail;
+exports.getVerifyReceivedEmail = getVerifyReceivedEmail;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../configs/config");
+function headers(token) {
+    return {
+        headers: {
+            'Content-Type': 'application/json',
+            'cookie': `authToken=${token}`
+        }
+    };
+}
+function auth() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield axios_1.default.post(config_1.config.auxtaURL + 'login', config_1.config.auxtaCredentials, {
+            headers: {
+                'Content-Type': 'application/json',
+            }
+        })
+            .then(({ data }) => {
+            return data.token;
+        })
+            .catch(() => {
+            return false;
+        });
+        if (token == false) {
+            token = axios_1.default.post(config_1.config.auxtaURL + 'login', config_1.config.auxtaCredentials, {
+                headers: {
+                    'Content-Type': 'application/json',
+                }
+            })
+                .then(({ data }) => {
+                return data.token;
+            })
+                .catch(() => {
+                throw new Error("Invalid login credentials");
+            });
+        }
+        return token;
+    });
+}
+function setTimeZone() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield auth();
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "set-timezone-organization", {
+            organization: config_1.config.organization,
+            timezone: config_1.config.timezone
+        }, headers(token))).data;
+    });
+}
+function setEmailProvider() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield auth();
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "set-email-provider-organization", {
+            organization: config_1.config.organization,
+            emailProvider: config_1.config.emailProvider
+        }, headers(token))).data;
+    });
+}
+function createEmptyReport(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield auth();
+        const moment = require('moment-timezone');
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "create-empty-report", {
+            environment: body.environment,
+            digitalProductToken: body.digitalProduct,
+            bucket: body.bucket,
+            start: moment().tz(config_1.config.timezone),
+            emailProvider: config_1.config.emailProvider,
+            url: body.baseUrl
+        }, headers(token))).data.reportId;
+    });
+}
+function uploadStep(stepLog, scenarioName, screenshot, errMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let scenarios = [];
+        let token = yield auth();
+        let lastStep = stepLog[stepLog.length - 1];
+        const stepLogFormat = JSON.parse(JSON.stringify(stepLog));
+        stepLogFormat.pop();
+        try {
+            for (let i = 0; i < stepLogFormat.length; i++) {
+                const st = stepLogFormat[i];
+                const emb = (_a = st === null || st === void 0 ? void 0 : st.result) === null || _a === void 0 ? void 0 : _a.embedding;
+                if (emb && typeof st.embeddings === 'undefined') {
+                    st.embeddings = [emb];
+                }
+            }
+        }
+        catch (_b) { }
+        try {
+            const byTab = (errMessage === null || errMessage === void 0 ? void 0 : errMessage.byTab) || undefined;
+            if (byTab) {
+                for (let idx = 0; idx < stepLogFormat.length; idx++) {
+                    const step = stepLogFormat[idx];
+                    if (typeof (step === null || step === void 0 ? void 0 : step.name) === 'string') {
+                        const m = step.name.match(/^(\d+)\s+Image/i);
+                        if (m) {
+                            const tabNum = Number(m[1]);
+                            const tabErr = byTab[String(tabNum)] || byTab[tabNum];
+                            if (tabErr) {
+                                stepLogFormat[idx] = Object.assign({}, step, {
+                                    result: Object.assign({}, step.result, {
+                                        error_message: JSON.stringify(tabErr)
+                                    })
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (_c) { }
+        let output = (yield axios_1.default.post(config_1.config.auxtaURL + "create-steps", {
+            json: {
+                name: scenarioName,
+                steps: [
+                    ...stepLogFormat,
+                    (lastStep.result.status == 'failed')
+                        ? Object.assign(lastStep, {
+                            result: Object.assign(Object.assign({}, lastStep.result), { error_message: JSON.stringify(errMessage) })
+                        })
+                        : lastStep,
+                    {
+                        keyword: "After",
+                        result: {
+                            status: "passed",
+                            duration: 2678000000
+                        },
+                        embeddings: (screenshot) ? [{
+                                data: screenshot,
+                                mime_type: "image/png"
+                            }] : undefined,
+                    }
+                ],
+            }
+        }, headers(token))).data.scenarios;
+        scenarios.push({
+            stepRef: output.stepRef,
+            name: output.name,
+            status: output.status,
+            stepsCount: output.stepsCount
+        });
+        return scenarios;
+    });
+}
+function uploadScenario(stepRes, scenarioName, uri, hasFailed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "create-scenario", {
+            json: {
+                name: scenarioName,
+                uri: uri
+            },
+            scenarios: stepRes,
+            hasFailed: hasFailed
+        }, headers(token))).data;
+    });
+}
+function updateReport(reportId, scenario, steps, isFinal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        const moment = require('moment-timezone');
+        yield axios_1.default.post(config_1.config.auxtaURL + "update-inprogress-report", {
+            reportId: reportId,
+            isFinal: isFinal,
+            end: moment().tz(config_1.config.timezone),
+            data: Object.assign({ scenario: {
+                    scenarioRef: scenario.scenarioId,
+                    name: scenario.scenarioName,
+                    uri: scenario.scenarioUri,
+                    status: scenario.status,
+                    scenariosCount: scenario.scenariosCount,
+                    lastTag: scenario.lastTag
+                } }, steps)
+        }, headers(token));
+    });
+}
+function getReport(reportId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios_1.default.post(config_1.config.auxtaURL + "get-report", { reportId: reportId }, headers(token))).data;
+    });
+}
+function getLastDayResults() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios_1.default.get(config_1.config.auxtaURL + `get-last-day-results?url=${config_1.config.baseURL}`, headers(token))).data.results;
+    });
+}
+function compareScreenshots(key_1) {
+    return __awaiter(this, arguments, void 0, function* (key, screenshot = new Uint8Array()) {
+        let token = yield auth();
+        const embedding = {
+            data: screenshot,
+            mime_type: "image/png"
+        };
+        return (yield axios_1.default.post(`${config_1.config.auxtaURL}save-compared-screenshot`, {
+            organization: config_1.config.organization,
+            key: key,
+            embedding: embedding,
+        }, headers(token))).data;
+    });
+}
+function postNotifications(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios_1.default.post(`${config_1.config.auxtaURL}post-notification-after-run-background`, {
+            environmentName: body.environment,
+            digitalProductToken: body.digitalProduct,
+            organizationName: body.organization,
+            bucketName: body.bucket,
+            reportId: body.reportId,
+            isOfficial: body.isOfficial
+        }, headers(token));
+    });
+}
+function postNotificationsOnFail(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios_1.default.post(`${config_1.config.auxtaURL}post-notifications-after-case-fail-background`, {
+            environmentName: body.environment,
+            digitalProductToken: body.digitalProduct,
+            organizationName: body.organization,
+            bucketName: body.bucket,
+            reportId: body.reportId,
+            featureName: body.featureName,
+            scenarioName: body.scenarioName,
+            isOfficial: body.isOfficial
+        }, headers(token));
+    });
+}
+function getVerifyReceivedEmail(from_name, from_email, subject, body, link) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return yield axios_1.default.post(`${config_1.config.auxtaURL}get-verify-received-email`, {
+            from_name: from_name,
+            from_email: from_email,
+            subject: subject,
+            body: body,
+            link: link
+        }, headers(token));
+    });
+}

package/build/auxta/services/runtime.service.d.ts

@@ -0,0 +1,16 @@
+export interface RunTime {
+    duration: String;
+    startTime: Date;
+    endTime: Date;
+}
+export declare class Runtime {
+    private start;
+    private end;
+    private runtime;
+    constructor(s: Date, e: Date);
+    returnRuntime(): RunTime;
+    private calculateDuration;
+    private splitAtDecimanlMinutes;
+    private splitAtDecimanlHours;
+    private formatRuntime;
+}

package/build/auxta/services/runtime.service.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runtime = void 0;
+class Runtime {
+    constructor(s, e) {
+        this.start = s;
+        this.end = e;
+    }
+    returnRuntime() {
+        let duration = this.formatRuntime(this.calculateDuration());
+        let startTime = this.start;
+        let endTime = this.end;
+        this.runtime = { duration, startTime, endTime };
+        return this.runtime;
+    }
+    calculateDuration() {
+        let currentTime = new Date;
+        return currentTime.getTime() - this.start.getTime();
+    }
+    splitAtDecimanlMinutes(time) {
+        let minutes = time.toFixed(2).toString().split('.');
+        return `${minutes[0]}m ${(Number(minutes[1]) / 100 * 60).toFixed(0)}s`;
+    }
+    splitAtDecimanlHours(time) {
+        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`;
+    }
+    formatRuntime(duration) {
+        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);
+        }
+    }
+}
+exports.Runtime = Runtime;

package/build/auxta/utilities/runtime.helper.d.ts

@@ -0,0 +1,15 @@
+import { RunTime } from "../services/runtime.service";
+export declare class CalculateRuntime {
+    startTimeSeconds: string;
+    startTimeMinutes: string;
+    startTimeHours: string;
+    startTimeDay: string;
+    startTimeMonth: string;
+    endTimeSeconds: string;
+    endTimeMinutes: string;
+    endTimeHours: string;
+    endTimeDay: string;
+    endTimeMonth: string;
+    private runtime;
+    constructor(r: RunTime);
+}

package/build/auxta/utilities/runtime.helper.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculateRuntime = void 0;
+class CalculateRuntime {
+    constructor(r) {
+        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}`;
+    }
+}
+exports.CalculateRuntime = CalculateRuntime;

package/build/auxta/utilities/screenshot.helper.d.ts

@@ -0,0 +1,3 @@
+import { Page } from "puppeteer";
+export declare function captureScreenshot(): Promise<Buffer<ArrayBufferLike> | undefined>;
+export declare function captureScreenshotPage(page: Page): Promise<Buffer<ArrayBufferLike> | undefined>;

package/build/auxta/utilities/screenshot.helper.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureScreenshot = captureScreenshot;
+exports.captureScreenshotPage = captureScreenshotPage;
+const puppeteer_1 = __importDefault(require("../../puppeteer/puppeteer"));
+const log_service_1 = __importDefault(require("../services/log.service"));
+const status_of_step_1 = __importDefault(require("../enums/status-of.step"));
+const RETRY_NUMBERS = 10;
+function captureScreenshot() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pages = yield puppeteer_1.default.defaultPage.browser().pages();
+        if (!pages.length)
+            return undefined;
+        for (let i = 0; i < pages.length; i++) {
+            const page = pages[i];
+            if ((pages.length - 1) == i || pages.length == 1) {
+                let count = 0;
+                while (count <= RETRY_NUMBERS) {
+                    try {
+                        const lastPage = pages[pages.length - 1] || puppeteer_1.default.defaultPage;
+                        const screenshotBuffer = yield lastPage.screenshot({
+                            captureBeyondViewport: false,
+                            encoding: 'binary'
+                        });
+                        if (Buffer.isBuffer(screenshotBuffer))
+                            return screenshotBuffer;
+                    }
+                    catch (e) {
+                        if (count == RETRY_NUMBERS) {
+                            log_service_1.default.push('When', log_service_1.default.tag, e.toString(), status_of_step_1.default.FAILED);
+                            return undefined;
+                        }
+                    }
+                    count++;
+                }
+            }
+            else {
+                let count = 0;
+                while (count <= RETRY_NUMBERS) {
+                    try {
+                        const screenshotBuffer = yield page.screenshot({
+                            captureBeyondViewport: false,
+                            encoding: 'binary'
+                        });
+                        if (Buffer.isBuffer(screenshotBuffer)) {
+                            log_service_1.default.push("When", log_service_1.default.tag, `${i} Image`, status_of_step_1.default.FAILED, screenshotBuffer);
+                            break;
+                        }
+                    }
+                    catch (e) {
+                        if (count == RETRY_NUMBERS) {
+                            log_service_1.default.push('When', log_service_1.default.tag, e.toString(), status_of_step_1.default.FAILED);
+                            return undefined;
+                        }
+                    }
+                    count++;
+                }
+            }
+        }
+        return undefined;
+    });
+}
+function captureScreenshotPage(page) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let count = 0;
+        while (count <= RETRY_NUMBERS) {
+            try {
+                const pages = yield puppeteer_1.default.defaultPage.browser().pages();
+                log_service_1.default.push('When', log_service_1.default.tag, `Before the screenshot the number of pages are ${pages.length}`, status_of_step_1.default.PASSED);
+                const screenshotBuffer = yield page.screenshot({
+                    fullPage: true,
+                    captureBeyondViewport: false,
+                    encoding: 'binary'
+                });
+                if (Buffer.isBuffer(screenshotBuffer))
+                    return screenshotBuffer;
+            }
+            catch (e) {
+                if (count == RETRY_NUMBERS) {
+                    log_service_1.default.push('When', log_service_1.default.tag, e.toString(), status_of_step_1.default.FAILED);
+                    return undefined;
+                }
+            }
+            count++;
+        }
+        return undefined;
+    });
+}

package/build/auxta/utilities/start-suite.helper.d.ts

@@ -0,0 +1,17 @@
+export declare function startSuite(suites: string[], reportId?: string): Promise<{
+    nextSuites?: undefined;
+    reportId?: undefined;
+    currentSuite?: undefined;
+    retries?: undefined;
+} | {
+    nextSuites: string[];
+    reportId: string | undefined;
+    currentSuite: string | undefined;
+    retries: string;
+}>;
+export declare function retrySuite(suites: string[], reportId: string, currentSuite: string, retries: number): Promise<false | {
+    nextSuites: string[];
+    reportId: string;
+    currentSuite: string;
+    retries: number;
+}>;