@auxcode/auxta 1.3.16 → 1.3.17-beta.0

package/build/esm/auxta/hooks/report.hook.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { UploadModel } from "../models/upload.model";
+export declare function onTestEnd(body: any, featureName: string, scenarioName: string, statusCode: number, screenshotBuffer?: Buffer, errMessage?: object): Promise<{
+    nextSuites?: undefined;
+    reportId?: undefined;
+    currentSuite?: undefined;
+    retries?: undefined;
+} | {
+    nextSuites: string[];
+    reportId: string | undefined;
+    currentSuite: string | undefined;
+    retries: string;
+} | undefined>;
+export declare function afterComplete(body: UploadModel): Promise<void>;

package/build/esm/auxta/hooks/report.hook.js

@@ -0,0 +1,58 @@
+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());
+    });
+};
+import { basename } from 'path';
+import log from "../services/log.service";
+import { postNotifications, updateReport, uploadFeature, uploadScenario } from '../services/report.service';
+import { startSuite } from '../utilities/start-suite.helper';
+import { StatusOfStep } from "../enums/status-of.step";
+export function onTestEnd(body, featureName, scenarioName, statusCode, screenshotBuffer, errMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let isFinal = false;
+        if (process.env.ENVIRONMENT == "LIVE") {
+            console.log('--- Uploading scenario and feature for AUXTA report ---');
+            const stepsArr = log.returnScenarioReport();
+            try {
+                const scenarioRes = yield uploadScenario(stepsArr, scenarioName, screenshotBuffer, errMessage);
+                const featureRes = yield uploadFeature(scenarioRes, featureName, basename(__filename), (statusCode != 200));
+                const feature = {
+                    featureId: featureRes.featureRef,
+                    featureName: featureRes.name,
+                    featureUri: featureRes.uri,
+                    status: featureRes.status,
+                    scenariosCount: featureRes.scenariosCount
+                };
+                const stepCounts = {
+                    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));
+                yield 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)
+            yield afterComplete(body);
+        else if (body && body.nextSuites) {
+            return yield startSuite(body.nextSuites, body.reportId);
+        }
+    });
+}
+export function afterComplete(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (process.env.ENVIRONMENT == "LIVE")
+            yield postNotifications(body);
+    });
+}

package/build/esm/auxta/models/upload.model.d.ts

@@ -0,0 +1,32 @@
+export declare class UploadModel {
+    private _reportId;
+    private _nextSuites;
+    private _digitalProduct;
+    private _baseUrl;
+    private readonly _organization;
+    private _environment;
+    private _currentSuite;
+    private _retries;
+    private _featureName;
+    private _scenarioName;
+    constructor(org: string, baseUrl: string, digitalProduct: string, environment: string);
+    set currentSuite(value: string);
+    set retries(value: number);
+    get currentSuite(): string;
+    get retries(): number;
+    get reportId(): string;
+    set reportId(value: string);
+    get nextSuites(): [];
+    set nextSuites(value: []);
+    get digitalProduct(): string;
+    set digitalProduct(value: string);
+    get organization(): string;
+    get baseUrl(): string;
+    set baseUrl(value: string);
+    get environment(): string;
+    set environment(value: string);
+    get featureName(): string;
+    set featureName(value: string);
+    get scenarioName(): string;
+    set scenarioName(value: string);
+}

package/build/esm/auxta/models/upload.model.js

@@ -0,0 +1,71 @@
+export class UploadModel {
+    constructor(org, baseUrl, digitalProduct, environment) {
+        this._reportId = '';
+        this._nextSuites = [];
+        this._currentSuite = '';
+        this._retries = 0;
+        this._organization = org;
+        this._digitalProduct = digitalProduct;
+        this._environment = environment;
+        this._baseUrl = baseUrl;
+        this._featureName = '';
+        this._scenarioName = '';
+    }
+    set currentSuite(value) {
+        this._currentSuite = value;
+    }
+    set retries(value) {
+        this._retries = value;
+    }
+    get currentSuite() {
+        return this._currentSuite;
+    }
+    get retries() {
+        return this._retries;
+    }
+    get reportId() {
+        return this._reportId;
+    }
+    set reportId(value) {
+        this._reportId = value;
+    }
+    get nextSuites() {
+        return this._nextSuites;
+    }
+    set nextSuites(value) {
+        this._nextSuites = value;
+    }
+    get digitalProduct() {
+        return this._digitalProduct;
+    }
+    set digitalProduct(value) {
+        this._digitalProduct = value;
+    }
+    get organization() {
+        return this._organization;
+    }
+    get baseUrl() {
+        return this._baseUrl;
+    }
+    set baseUrl(value) {
+        this._baseUrl = value;
+    }
+    get environment() {
+        return this._environment;
+    }
+    set environment(value) {
+        this._environment = value;
+    }
+    get featureName() {
+        return this._featureName;
+    }
+    set featureName(value) {
+        this._featureName = value;
+    }
+    get scenarioName() {
+        return this._scenarioName;
+    }
+    set scenarioName(value) {
+        this._scenarioName = value;
+    }
+}

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

@@ -0,0 +1,26 @@
+import { StatusOfStep } from "../enums/status-of.step";
+export interface Step {
+    keyword: string;
+    name: string;
+    result: {
+        status: StatusOfStep;
+        duration: number;
+    };
+}
+export declare class LogSteps {
+    private stepLog;
+    private lastStepTime;
+    statusCounter: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        suggestion: number;
+    };
+    addSuggestion(text: string): void;
+    clear(): void;
+    push(keyword: string, name: string, status: StatusOfStep): void;
+    returnScenarioReport(): Step[];
+    getStatusCount(status: StatusOfStep): number;
+}
+declare const log: LogSteps;
+export default log;

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

@@ -0,0 +1,43 @@
+import { StatusOfStep } from "../enums/status-of.step";
+export class LogSteps {
+    constructor() {
+        this.stepLog = [];
+        this.lastStepTime = new Date().getTime();
+        this.statusCounter = {
+            [StatusOfStep.PASSED]: 0,
+            [StatusOfStep.FAILED]: 0,
+            [StatusOfStep.SKIPPED]: 0,
+            [StatusOfStep.SUGGESTION]: 0,
+        };
+    }
+    addSuggestion(text) {
+        this.statusCounter[StatusOfStep.SUGGESTION]++;
+        this.stepLog.push({
+            keyword: 'Suggestion', name: text, result: { status: StatusOfStep.SUGGESTION, duration: 0 }
+        });
+    }
+    clear() {
+        this.stepLog = [];
+        this.statusCounter = {
+            [StatusOfStep.PASSED]: 0,
+            [StatusOfStep.FAILED]: 0,
+            [StatusOfStep.SKIPPED]: 0,
+            [StatusOfStep.SUGGESTION]: 0,
+        };
+    }
+    push(keyword, name, status) {
+        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;
+    }
+    returnScenarioReport() {
+        return this.stepLog;
+    }
+    getStatusCount(status) {
+        return this.statusCounter[status];
+    }
+}
+const log = new LogSteps();
+export default log;

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

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { Step } from "./log.service";
+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;
+}
+export declare function createEmptyReport(body: any): Promise<string>;
+export declare function uploadScenario(stepLog: Step[], scenarioName: string, screenshot?: Buffer, errMessage?: object): Promise<{
+    scenarioRef: any;
+    name: any;
+    status: any;
+    stepsCount: any;
+}[]>;
+export declare function uploadFeature(scenarioId: any[], scenarioName: string, uri: string, hasFailed: boolean): Promise<any>;
+export declare function updateReport(reportId: string, feature: Feature, steps: Steps, isFinal: boolean): Promise<void>;
+export declare function getReport(reportId: string): Promise<any>;
+export declare function getLastDayResults(): Promise<any>;
+export declare function postNotifications(body: UploadModel): Promise<void>;
+export declare function postNotificationsOnFail(body: UploadModel): Promise<void>;

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

@@ -0,0 +1,150 @@
+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());
+    });
+};
+import axios from "axios";
+import { config } from "../configs/config";
+function headers(token) {
+    return {
+        headers: {
+            'Content-Type': 'application/json',
+            'cookie': `authToken=${token}`
+        }
+    };
+}
+function auth() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return axios.post(config.auxtaURL + 'login', config.auxtaCredentials, {
+            headers: {
+                'Content-Type': 'application/json',
+            }
+        })
+            .then(({ data }) => {
+            return data.token;
+        })
+            .catch(() => {
+            throw new Error("Invalid login credentials");
+        });
+    });
+}
+export function createEmptyReport(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield auth();
+        return (yield axios.post(config.auxtaURL + "create-empty-report", {
+            environment: body.environment,
+            digitalProductName: body.digitalProduct,
+            start: new Date(),
+            url: body.baseUrl
+        }, headers(token))).data.reportId;
+    });
+}
+export function uploadScenario(stepLog, scenarioName, screenshot, errMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let scenarios = [];
+        let token = yield auth();
+        let lastStep = stepLog[stepLog.length - 1];
+        const stepLogFormat = JSON.parse(JSON.stringify(stepLog));
+        stepLogFormat.pop();
+        let output = (yield axios.post(config.auxtaURL + "create-scenario", {
+            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.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 function uploadFeature(scenarioId, scenarioName, uri, hasFailed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios.post(config.auxtaURL + "create-feature", {
+            json: {
+                name: scenarioName,
+                uri: uri
+            },
+            scenarios: scenarioId,
+            hasFailed: hasFailed
+        }, headers(token))).data;
+    });
+}
+export function updateReport(reportId, feature, steps, isFinal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios.post(config.auxtaURL + "update-inprogress-report", {
+            reportId: reportId,
+            isFinal: isFinal,
+            data: Object.assign({ feature: {
+                    featureRef: feature.featureId,
+                    name: feature.featureName,
+                    uri: feature.featureUri,
+                    status: feature.status,
+                    scenariosCount: feature.scenariosCount
+                } }, steps)
+        }, headers(token));
+    });
+}
+export function getReport(reportId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios.post(config.auxtaURL + "get-report", { reportId: reportId }, headers(token))).data;
+    });
+}
+export function getLastDayResults() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        return (yield axios.get(config.auxtaURL + `get-last-day-results?url=${config.baseURL}`, headers(token))).data.results;
+    });
+}
+export function postNotifications(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios.post(`${config.auxtaURL}post-notification-after-run-background`, {
+            environmentName: body.environment,
+            digitalProductName: body.digitalProduct,
+            organizationName: body.organization,
+            reportId: body.reportId,
+        }, headers(token));
+    });
+}
+export function postNotificationsOnFail(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let token = yield auth();
+        yield axios.post(`${config.auxtaURL}post-notifications-after-case-fail-background`, {
+            environmentName: body.environment,
+            digitalProductName: body.digitalProduct,
+            organizationName: body.organization,
+            reportId: body.reportId,
+            featureName: body.featureName,
+            scenarioName: body.scenarioName
+        }, headers(token));
+    });
+}

package/build/esm/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);
+    private calculateDuration;
+    private splitAtDecimanlMinutes;
+    private splitAtDecimanlHours;
+    private formatRuntime;
+    returnRuntime(): RunTime;
+}

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

@@ -0,0 +1,37 @@
+export class Runtime {
+    constructor(s, e) {
+        this.start = s;
+        this.end = e;
+    }
+    calculateDuration() {
+        let currentTime = new Date;
+        let duration = currentTime.getTime() - this.start.getTime();
+        return duration;
+    }
+    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);
+        }
+    }
+    returnRuntime() {
+        let duration = this.formatRuntime(this.calculateDuration());
+        let startTime = this.start;
+        let endTime = this.end;
+        this.runtime = { duration, startTime, endTime };
+        return this.runtime;
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+export 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}`;
+    }
+}

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

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function captureScreenshot(): Promise<Buffer | undefined>;

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

@@ -0,0 +1,29 @@
+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());
+    });
+};
+import puppeteer from "../../puppeteer/puppeteer";
+export function captureScreenshot() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pages = yield puppeteer.defaultPage.browser().pages();
+            if (!pages.length)
+                return undefined;
+            const lastPage = pages[pages.length - 1] || puppeteer.defaultPage;
+            const screenshotBuffer = yield lastPage.screenshot({
+                fullPage: true,
+                encoding: 'binary'
+            });
+            if (Buffer.isBuffer(screenshotBuffer))
+                return screenshotBuffer;
+        }
+        catch (e) {
+        }
+        return undefined;
+    });
+}

package/build/esm/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;
+}>;

package/build/esm/auxta/utilities/start-suite.helper.js

@@ -0,0 +1,26 @@
+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());
+    });
+};
+export function startSuite(suites, reportId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (suites.length === 0)
+            return {};
+        const next = suites.shift();
+        return { nextSuites: suites, reportId: reportId, currentSuite: next, retries: "0" };
+    });
+}
+export function retrySuite(suites, reportId, currentSuite, retries) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('I repeat again the current suite: ' + currentSuite);
+        if (retries >= 2) {
+            return false;
+        }
+        return { nextSuites: suites, reportId: reportId, currentSuite: currentSuite, retries: retries };
+    });
+}

package/build/esm/macros/helpers/Aux2faAuth.d.ts

@@ -0,0 +1,7 @@
+export declare class Aux2faAuth {
+    authenticator(): any;
+    verifyToken(token: string): boolean;
+    private getSecret;
+}
+declare const _default: Aux2faAuth;
+export default _default;

package/build/esm/macros/helpers/Aux2faAuth.js

@@ -0,0 +1,25 @@
+const twofactor = require("node-2fa");
+export class Aux2faAuth {
+    authenticator() {
+        const aux2fe_secret = this.getSecret();
+        return twofactor.generateToken(aux2fe_secret).token;
+    }
+    verifyToken(token) {
+        const aux2fe_secret = this.getSecret();
+        const result = twofactor.verifyToken(aux2fe_secret, token);
+        if (result != null) {
+            if (result.delta == 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getSecret() {
+        const aux2fe_secret = process.env.aux2fe_secret;
+        if (!aux2fe_secret) {
+            throw new Error('No 2fe secret set');
+        }
+        return aux2fe_secret;
+    }
+}
+export default new Aux2faAuth();

package/build/esm/macros/helpers/code.helper.d.ts

@@ -0,0 +1,23 @@
+import { StatusOfStep } from "../../auxta/enums/status-of.step";
+import { ExtendDefaultPage } from "./extend-default-page";
+import { Page } from "puppeteer";
+export declare class FunctionHelper extends ExtendDefaultPage {
+    log(keyword: string, name: string, status: StatusOfStep): void;
+    suggest(name: string): void;
+    private getEscapedText;
+    private waitClick;
+    clickByText(selector: string, text: string, dotOrText?: string, page?: Page, time?: number, log_message?: boolean): Promise<void>;
+    clickByTextWithClass(class_selector: string, class_name: string, selector: string, text: string, dotOrText?: string, page?: Page): Promise<void>;
+    waitForSelectorWithText(selector: string, text: string, dotOrText?: string, page?: Page): Promise<void>;
+    timeout(timeout?: number, page?: Page): Promise<void>;
+    waitForSelector(option: string, selector: string, time?: number, page?: Page, log_message?: boolean): Promise<void>;
+    urlContains(selector: string, page?: Page): Promise<void>;
+    pressEnter(page?: Page): Promise<void>;
+    emulate(phone_name: string, page?: Page): Promise<void>;
+    restartBrowser(): Promise<void>;
+    clickAndWaitForPageToBeCreated(selector: string, page?: Page): Promise<void>;
+    closeLastPage(page?: Page): Promise<void>;
+    microsoftLogin(button: string, email: string, password: string): Promise<void>;
+}
+declare const _default: FunctionHelper;
+export default _default;