@mablhq/playwright-tools 2.49.1

package/providers/exportRequestProvider.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportRequestProvider = void 0;
+const mablApi_1 = require("../mablApi");
+const loggingProvider_1 = require("./logging/loggingProvider");
+const basicApiClient_1 = require("../api/basicApiClient");
+const fs = require('fs');
+const ora = require('ora');
+const chalk = require('chalk');
+class ExportRequestProvider {
+    constructor(apiClient, targetEntityId, targetEntityType, targetContentTypes, outputFilepath) {
+        this.pollingTimeoutMilliseconds = 10 * 60 * 1000;
+        this.pollingIntervalMilliseconds = 1000;
+        this.exportStartEpochMilliseconds = 0;
+        this.continuationStatuses = [
+            mablApi_1.ExportRequest.StatusEnum.Queued,
+            mablApi_1.ExportRequest.StatusEnum.Running,
+        ];
+        this.apiClient = apiClient;
+        this.targetEntityId = targetEntityId;
+        this.targetEntityType = targetEntityType;
+        this.contentTypes = targetContentTypes;
+        this.outputFilepath = outputFilepath;
+    }
+    isExportIncomplete() {
+        var _a;
+        if ((_a = this.latestRequest) === null || _a === void 0 ? void 0 : _a.status) {
+            return this.continuationStatuses.includes(this.latestRequest.status);
+        }
+        return false;
+    }
+    isExportCompleted() {
+        return !this.isExportIncomplete();
+    }
+    static mapStatusToColor(status) {
+        switch (status) {
+            case mablApi_1.ExportRequest.StatusEnum.Queued:
+                return 'gray';
+            case mablApi_1.ExportRequest.StatusEnum.Running:
+                return 'yellow';
+            case mablApi_1.ExportRequest.StatusEnum.Completed:
+                return 'green';
+            case mablApi_1.ExportRequest.StatusEnum.Failed:
+            case mablApi_1.ExportRequest.StatusEnum.Terminated:
+                return 'red';
+            default:
+                return 'orange';
+        }
+    }
+    async pollForStatusUpdate(lastRequestId) {
+        const newLatestRequest = await this.apiClient.getExportRequest(lastRequestId);
+        this.latestRequest = newLatestRequest;
+        const statusColor = ExportRequestProvider.mapStatusToColor(newLatestRequest.status);
+        const updatedMessage = `Processing export [${chalk.magenta.bold(lastRequestId)}] status: [${chalk
+            .keyword(statusColor)
+            .bold(newLatestRequest.status.toString())}]`;
+        updateSpinnerText(updatedMessage, this.exportStatusSpinner);
+        return this.latestRequest;
+    }
+    async awaitCompletion() {
+        var _a;
+        if (!((_a = this.latestRequest) === null || _a === void 0 ? void 0 : _a.id)) {
+            throw new Error('CreateExportRequest is undefined');
+        }
+        await this.pollForStatusUpdate(this.latestRequest.id);
+        const notTimedOut = Date.now() - this.exportStartEpochMilliseconds <
+            this.pollingTimeoutMilliseconds;
+        if (notTimedOut && this.isExportIncomplete()) {
+            return new Promise((resolve, reject) => {
+                setTimeout(() => this.awaitCompletion()
+                    .then(() => resolve())
+                    .catch((error) => reject(error)), this.pollingIntervalMilliseconds);
+            });
+        }
+    }
+    async processExport() {
+        try {
+            const testRun = await this.apiClient.getTestRun(this.targetEntityId);
+            if (testRun.test_type === mablApi_1.TestTypeEnum.Api) {
+                loggingProvider_1.logger.error(chalk.red(`Test run export not supported for API test runs: ${this.targetEntityId}`));
+                process.exit(1);
+            }
+            loggingProvider_1.logger.info(`Export ${this.targetEntityType} [${chalk.magenta.bold(this.targetEntityId)}]`);
+            this.createExportSpinner = ora({
+                prefixText: ' ',
+                text: 'Creating export request',
+            }).start();
+            const targetContent = this
+                .contentTypes;
+            this.latestRequest = await this.apiClient.createExportRequest(this.targetEntityId, targetContent);
+            const updateMessage = `Creating export request [${chalk.magenta.bold(this.latestRequest.id)}].  Types to export: ${chalk.magenta.bold(this.contentTypes.join(','))}`;
+            updateSpinnerSuccess(this.createExportSpinner, updateMessage);
+            this.exportStartEpochMilliseconds = Date.now();
+            this.latestRequest = await this.apiClient.getExportRequest(this.latestRequest.id);
+            this.exportStatusSpinner = ora({
+                prefixText: ' ',
+                text: 'Processing export',
+            }).start();
+            await this.awaitCompletion();
+            if (!this.isExportCompleted()) {
+                loggingProvider_1.logger.error(chalk.red(`Export request [${this.latestRequest
+                    .id}] timed out. Please try again.`));
+                process.exit(1);
+            }
+            switch (this.latestRequest.status) {
+                case mablApi_1.ExportRequest.StatusEnum.Failed:
+                case mablApi_1.ExportRequest.StatusEnum.Terminated:
+                    updateSpinnerFail(this.createExportSpinner);
+                    loggingProvider_1.logger.error(chalk.red(`Export request [${this.latestRequest.id}] ${this.latestRequest.status
+                        .toString()
+                        .toUpperCase()}. Please try again.`));
+                    process.exit(1);
+                    break;
+                case mablApi_1.ExportRequest.StatusEnum.Completed:
+                default:
+                    updateSpinnerSuccess(this.exportStatusSpinner);
+            }
+            const downloadUrl = this.latestRequest.output_signed_url;
+            if (!downloadUrl) {
+                throw new Error(`No download url provided for ExportRequest [${this.latestRequest.id}]`);
+            }
+            const outputFilename = this.outputFilepath || getDownloadFilename(downloadUrl);
+            this.exportDownloadSpinner = ora({
+                prefixText: ' ',
+                text: `Downloading export artifact to [${chalk.magenta.bold(outputFilename)}]`,
+            }).start();
+            const client = await basicApiClient_1.BasicApiClient.create();
+            const responseData = await client.makeGetRequest(downloadUrl, undefined, {
+                headers: {
+                    Accept: 'application/zip',
+                },
+                responseType: 'stream',
+            });
+            const writer = fs.createWriteStream(outputFilename);
+            await new Promise((resolve, reject) => {
+                try {
+                    responseData.pipe(writer);
+                    writer.on('error', (err) => {
+                        writer.close();
+                        reject(err);
+                    });
+                    writer.on('finish', () => {
+                        writer.close();
+                        resolve();
+                    });
+                }
+                catch (exception) {
+                    reject(exception);
+                }
+            });
+            updateSpinnerSuccessStop(this.exportDownloadSpinner);
+            return outputFilename;
+        }
+        finally {
+            [
+                this.createExportSpinner,
+                this.exportStatusSpinner,
+                this.exportDownloadSpinner,
+            ]
+                .forEach((spinner) => {
+                if (spinner === null || spinner === void 0 ? void 0 : spinner.isSpinning) {
+                    spinner.fail();
+                }
+            });
+        }
+    }
+}
+exports.ExportRequestProvider = ExportRequestProvider;
+const filenameExtractorRegex = /\/([^\/]+)\?/;
+function getDownloadFilename(downloadUrl) {
+    const urlParts = downloadUrl.match(filenameExtractorRegex);
+    if (urlParts && urlParts.length >= 2) {
+        return urlParts[1];
+    }
+    throw new Error('Output URL undefined');
+}
+function updateSpinnerSuccess(spinner, message) {
+    if (spinner) {
+        spinner.succeed(message);
+    }
+}
+function updateSpinnerSuccessStop(spinner, message) {
+    if (spinner) {
+        spinner.stop().succeed(message);
+    }
+}
+function updateSpinnerFail(spinner, message) {
+    if (spinner) {
+        spinner.fail(message);
+    }
+}
+function updateSpinnerText(message, spinner) {
+    if (spinner) {
+        spinner.text = message;
+    }
+}

package/providers/logging/loggingProvider.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.LogLevel = void 0;
+const winston = __importStar(require("winston"));
+const winston_transport_1 = __importDefault(require("winston-transport"));
+const defaultEnv_1 = require("../../env/defaultEnv");
+const { MESSAGE } = require('triple-beam');
+const stripAnsi = require('strip-ansi');
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Error"] = "error";
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class CliTransport extends winston_transport_1.default {
+    constructor(opts) {
+        super(opts);
+    }
+    log(info, callback) {
+        this.emit('logged', info);
+        switch (info.level) {
+            case LogLevel.Error:
+                console.error(info[MESSAGE]);
+                break;
+            case LogLevel.Warn:
+                console.warn(info[MESSAGE]);
+                break;
+            case LogLevel.Info:
+            case LogLevel.Debug:
+                console.log(info[MESSAGE]);
+                break;
+            default:
+                break;
+        }
+        callback();
+    }
+}
+exports.logger = winston.createLogger({
+    level: defaultEnv_1.CONSOLE_LOGGING_LEVEL,
+    format: winston.format.printf((info) => `${stripAnsi(info.message)}`),
+    defaultMeta: { service: 'mabl-cli' },
+    transports: [
+        new CliTransport({
+            format: winston.format.printf((info) => { var _a; return `${(_a = info.message) !== null && _a !== void 0 ? _a : info[MESSAGE]}`; }),
+        }),
+    ],
+});
+exports.logger.constructor.prototype.logNewLine = (level = LogLevel.Info) => {
+    const emptyNewLine = '';
+    switch (level) {
+        case LogLevel.Error:
+            exports.logger.error(emptyNewLine);
+            break;
+        case LogLevel.Warn:
+            exports.logger.warn(emptyNewLine);
+            break;
+        case LogLevel.Debug:
+        case LogLevel.Info:
+        default:
+            exports.logger.info(emptyNewLine);
+            break;
+    }
+};

package/providers/scmContextInterfaces.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildTypes = void 0;
+var BuildTypes;
+(function (BuildTypes) {
+    BuildTypes["AzureDevOps"] = "azure_devops";
+    BuildTypes["BitbucketPipe"] = "bitbucket_pipe";
+    BuildTypes["CircleCi"] = "circle_ci";
+    BuildTypes["CloudBuild"] = "cloudbuild";
+    BuildTypes["Codeship"] = "codeship";
+    BuildTypes["GithubAction"] = "github_action";
+    BuildTypes["Jenkins"] = "jenkins";
+    BuildTypes["Travis"] = "travis";
+})(BuildTypes || (exports.BuildTypes = BuildTypes = {}));

package/providers/scmContextProvider.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScmContextProvider = void 0;
+const scmContextInterfaces_1 = require("./scmContextInterfaces");
+const loggingProvider_1 = require("./logging/loggingProvider");
+const getRepoInfo = require('git-repo-info');
+const { exec } = require('child_process');
+function processBuildEnv(envVariables, mapper) {
+    const results = {};
+    envVariables.forEach((value, key) => {
+        mapper(key, value, results);
+    });
+    if (results.isCorrectType) {
+        return results;
+    }
+    return;
+}
+class ScmContextProvider {
+    constructor(processRef) {
+        this.envVariables = this.extractEnvVariables(processRef);
+    }
+    async extractScmAndBuildInfo() {
+        try {
+            return this.innerExtractScmAndBuildInfo();
+        }
+        catch (error) {
+            loggingProvider_1.logger.error('Error collecting build information. Using defaults.');
+            return;
+        }
+    }
+    async innerExtractScmAndBuildInfo() {
+        const maybeBuildInfo = this.attemptExtractBuildInfo();
+        let scmIfo = await this.attemptGitChildProcessCall();
+        if (!scmIfo) {
+            scmIfo = this.attemptGitSoftInterrogation();
+        }
+        return {
+            buildInfo: maybeBuildInfo,
+            scmInfo: scmIfo,
+        };
+    }
+    attemptExtractBuildInfo() {
+        const processors = [
+            () => this.getForCircleCi(),
+            () => this.getForCloudBuild(),
+            () => this.getForCodeship(),
+            () => this.getForJenkins(),
+            () => this.getForTravis(),
+        ];
+        let buildResultHolder;
+        processors.some((processor) => {
+            buildResultHolder = processor();
+            return buildResultHolder;
+        });
+        return buildResultHolder;
+    }
+    extractEnvVariables(processRef) {
+        const result = new Map();
+        Object.entries(processRef).forEach(([key, value]) => {
+            if (value && value !== '') {
+                result.set(key, value);
+            }
+        });
+        return result;
+    }
+    getForCloudBuild() {
+        function mapper(key, value, results) {
+            switch (key) {
+                case '_HEAD_BRANCH':
+                    results.pullRequestHeadBranch = value;
+                    break;
+                case '_BASE_BRANCH':
+                    results.pullRequestBaseBranch = value;
+                    break;
+                case '_HEAD_REPO_URL':
+                    results.pullRequestHeadRepo = value;
+                    break;
+                case '_PR_NUMBER':
+                    results.pullRequestId = value;
+                    break;
+                case 'PROJECT_ID':
+                    results.projectId = value;
+                    break;
+                case 'BUILD_ID':
+                    results.buildId = value;
+                    break;
+                case 'COMMIT_SHA':
+                    results.commitSha = value;
+                    break;
+                case 'SHORT_SHA':
+                    results.shortSha = value;
+                    results.isCorrectType = true;
+                    results.buildType = scmContextInterfaces_1.BuildTypes.CloudBuild;
+                    break;
+                case 'REPO_NAME':
+                    results.repoName = value;
+                    break;
+                case 'BRANCH_NAME':
+                    results.branchName = value;
+                    break;
+                case 'TAG_NAME':
+                    results.tagName = value;
+                    break;
+                case 'REVISION_ID':
+                    results.revisionId = value;
+                    break;
+                default:
+            }
+        }
+        return processBuildEnv(this.envVariables, mapper);
+    }
+    getForCircleCi() {
+        function mapper(key, value, results) {
+            switch (key) {
+                case 'CIRCLE_PR_NUMBER':
+                    results.pullRequestId = value;
+                    break;
+                case 'CIRCLE_PR_USERNAME':
+                    results.pullRequestUsername = value;
+                    break;
+                case 'CIRCLE_WORKFLOW_ID':
+                    results.workflowId = value;
+                    break;
+                case 'CIRCLECI':
+                    results.isCorrectType = value === 'true';
+                    results.buildType = scmContextInterfaces_1.BuildTypes.CircleCi;
+                    break;
+                case 'CIRCLE_SHA1':
+                    results.commitSha = value;
+                    results.revisionId = value;
+                    break;
+                case 'CIRCLE_USERNAME':
+                    results.commitSha = value;
+                    break;
+                case 'CIRCLE_TAG':
+                    results.tagName = value;
+                    break;
+                case 'CIRCLE_PR_REPONAME':
+                    results.pullRequestRepo = value;
+                    break;
+                case 'CIRCLE_PROJECT_REPONAME':
+                    results.repoName = value;
+                    break;
+                case 'CIRCLE_PROJECT_USERNAME':
+                    results.projectUsername = value;
+                    break;
+                case 'CIRCLE_REPOSITORY_URL':
+                    results.repoUrl = value;
+                    break;
+                case 'CIRCLE_BRANCH':
+                    results.branchName = value;
+                    break;
+                case 'CIRCLE_BUILD_NUM':
+                    results.buildId = value;
+                    break;
+                case 'CIRCLE_BUILD_URL':
+                    results.buildUrl = value;
+                    break;
+                case 'CIRCLE_JOB':
+                    results.jobName = value;
+                    break;
+                default:
+            }
+        }
+        return processBuildEnv(this.envVariables, mapper);
+    }
+    getForTravis() {
+        function mapper(key, value, results) {
+            switch (key) {
+                case 'TRAVIS_PULL_REQUEST':
+                    if (value !== 'false') {
+                        results.pullRequestId = value;
+                    }
+                    break;
+                case 'TRAVIS_PULL_REQUEST_BRANCH':
+                    results.pullRequestBranch = value;
+                    break;
+                case 'TRAVIS_REPO_SLUG':
+                    const parts = value.split('/');
+                    if (parts.length === 2) {
+                        results.repoOwner = parts[0];
+                        results.repoName = parts[1];
+                    }
+                    break;
+                case 'TRAVIS':
+                    results.isCorrectType = value === 'true';
+                    results.buildType = scmContextInterfaces_1.BuildTypes.Travis;
+                    break;
+                case 'TRAVIS_COMMIT':
+                    results.commitSha = value;
+                    results.revisionId = value;
+                    break;
+                case 'TRAVIS_TAG':
+                    results.tagName = value;
+                    break;
+                case 'TRAVIS_BRANCH':
+                    results.branchName = value;
+                    break;
+                case 'TRAVIS_BUILD_NUMBER':
+                    results.buildId = value;
+                    break;
+                case 'TRAVIS_BUILD_WEB_URL':
+                    results.buildUrl = value;
+                    break;
+                case 'TRAVIS_JOB_NAME':
+                    results.jobName = value;
+                    break;
+                default:
+            }
+        }
+        return processBuildEnv(this.envVariables, mapper);
+    }
+    getForCodeship() {
+        function mapper(key, value, results) {
+            switch (key) {
+                case 'CI_PR_NUMBER':
+                    results.pullRequestId = value;
+                    break;
+                case 'CI_PULL_REQUEST':
+                    results.pullRequestUrl = value;
+                    break;
+                case 'CI_REPO_NAME':
+                    results.repoName = value;
+                    break;
+                case 'CI_NAME':
+                    results.isCorrectType = value === 'codeship';
+                    results.buildType = scmContextInterfaces_1.BuildTypes.Codeship;
+                    break;
+                case 'CI_COMMIT_ID':
+                    results.commitSha = value;
+                    results.revisionId = value;
+                    break;
+                case 'CI_BRANCH':
+                    results.branchName = value;
+                    break;
+                case 'CI_BUILD_ID':
+                    results.buildId = value;
+                    break;
+                default:
+            }
+        }
+        return processBuildEnv(this.envVariables, mapper);
+    }
+    getForJenkins() {
+        function mapper(key, value, results) {
+            switch (key) {
+                case 'GIT_URL':
+                    results.repoUrl = value;
+                    break;
+                case 'GIT_COMMIT':
+                    results.commitSha = value;
+                    results.revisionId = value;
+                    break;
+                case 'SVN_REVISION':
+                    results.revisionId = value;
+                    break;
+                case 'GIT_BRANCH':
+                case 'CVS_BRANCH':
+                    results.branchName = value;
+                    break;
+                case 'BUILD_URL':
+                    results.buildUrl = value;
+                    break;
+                case 'JOB_NAME':
+                    results.jobName = value;
+                    break;
+                case 'BUILD_TAG':
+                    results.isCorrectType = value.startsWith('jenkins');
+                    results.jobTag = value;
+                    results.buildType = scmContextInterfaces_1.BuildTypes.Jenkins;
+                    break;
+                case 'BUILD_NUMBER':
+                    results.buildId = value;
+                    break;
+                default:
+            }
+        }
+        return processBuildEnv(this.envVariables, mapper);
+    }
+    attemptGitSoftInterrogation() {
+        const gitInfo = getRepoInfo();
+        if (gitInfo) {
+            return {
+                commitSha: gitInfo.sha,
+                revisionId: gitInfo.sha,
+                branchName: gitInfo.branch,
+                tagName: gitInfo.tag,
+            };
+        }
+        return;
+    }
+    async attemptGitChildProcessCall() {
+        const repoUrlMatcher = /^origin\s+(\S+)\s+\(fetch\)/;
+        const repoBranchMatcher = /^(\S{1,256})/;
+        const repoShaMatch = /^([a-f0-9]{40})+/;
+        const showRepoRemoteCommand = 'git remote -v';
+        const showRepoBranchCommand = 'git rev-parse --abbrev-ref HEAD';
+        const showRepoShaCommand = 'git rev-parse HEAD';
+        const maybeRepoUrl = await this.executeGetRepoUrl(showRepoRemoteCommand, repoUrlMatcher);
+        if (!maybeRepoUrl) {
+            return;
+        }
+        const maybeRepoBranch = await this.executeGetRepoUrl(showRepoBranchCommand, repoBranchMatcher);
+        if (!maybeRepoBranch) {
+            return;
+        }
+        const maybeRepoSha = await this.executeGetRepoUrl(showRepoShaCommand, repoShaMatch);
+        if (!maybeRepoSha) {
+            return;
+        }
+        return {
+            branchName: maybeRepoBranch,
+            repoUrl: maybeRepoUrl,
+            revisionId: maybeRepoSha,
+            commitSha: maybeRepoSha,
+        };
+    }
+    executeGetRepoUrl(command, matcher) {
+        return new Promise((resolve, reject) => {
+            exec(command, (error, stdout) => {
+                if (error) {
+                    return reject(error);
+                }
+                if (matcher.test(stdout)) {
+                    const matchParts = stdout.match(matcher);
+                    if (matchParts && matchParts.length >= 1) {
+                        return resolve(matchParts[1]);
+                    }
+                }
+                resolve(undefined);
+            });
+        });
+    }
+}
+exports.ScmContextProvider = ScmContextProvider;