@testim/testim-cli 3.288.0 → 3.290.0-beta

package/commons/testimServicesApi.js

@@ -1,631 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const pako = require('pako');
-const pRetry = require('p-retry');
-const hash = require('object-hash');
-const utils = require('../utils');
-const config = require('./config');
-const constants = require('./constants');
-const httpRequest = require('./httpRequest');
-const testimCustomToken = require('./testimCustomToken');
-const { ArgError } = require('../errors');
-const { getLogger } = require('./logger');
-
-const runnerVersion = utils.getRunnerVersion();
-const logger = getLogger('testim service api');
-
-const DEFAULT_REQUEST_RETRY = 3;
-const GRID_PATH = '/grid';
-
-function getTokenHeader() {
-    return testimCustomToken.getCustomTokenV3()
-        .then(brearToken => {
-            if (!brearToken) {
-                throw new Error('Failed to get token from server');
-            }
-            return { Authorization: `Bearer ${brearToken}` };
-        });
-}
-
-function postAuth({
-    url, body, headers = {}, timeout, retry,
-}) {
-    return getTokenHeader()
-        .then(tokenHeaders => {
-            const finalHeaders = Object.assign({}, headers, tokenHeaders);
-            return httpRequest.post({
-                url: `${config.SERVICES_HOST}${url || ''}`,
-                body,
-                headers: finalHeaders,
-                timeout,
-                retry,
-            });
-        });
-}
-
-// eslint-disable-next-line default-param-last
-function postAuthFormData(url, fields, files, headers = {}, timeout) {
-    return getTokenHeader()
-        .then(tokenHeaders => {
-            const finalHeaders = Object.assign({}, headers, tokenHeaders);
-            return httpRequest.postForm(`${config.SERVICES_HOST}${url || ''}`, fields, files, finalHeaders, timeout);
-        });
-}
-
-function putAuth(url, body) {
-    return getTokenHeader()
-        .then(headers => httpRequest.put(`${config.SERVICES_HOST}${url || ''}`, body, headers));
-}
-
-function deleteAuth(url, body) {
-    return getTokenHeader()
-        .then(headers => httpRequest.delete(`${config.SERVICES_HOST}${url || ''}`, body, headers));
-}
-
-function getWithAuth(url, query, options, timeout) {
-    return getTokenHeader()
-        .then(headers => httpRequest.get(`${config.SERVICES_HOST}${url || ''}`, query, headers, timeout, options));
-}
-
-function getS3Artifact(url, timeout) {
-    return pRetry(() => getWithAuth(`/storage${url}`, null, { isBinary: true }, timeout), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function getTestPlan(projectId, testPlanNames) {
-    //TODO: need to be checked after 3 months to prevent users from using old version
-    const parseProperty = (dataValue) => (dataValue == null ? [] : (typeof (dataValue) === 'string' && JSON.parse(dataValue)) || dataValue);
-    return pRetry((() => getWithAuth('/testPlan', { projectId, name: testPlanNames.join(',') }), { retries: DEFAULT_REQUEST_RETRY }))
-        .then(body => body.map(testPlan => {
-            testPlan.testConfigIds = parseProperty(testPlan.testConfigIds);
-            testPlan.beforeAllLabels = parseProperty(testPlan.beforeAllLabels);
-            testPlan.testLabels = parseProperty(testPlan.testLabels);
-            testPlan.afterAllLabels = parseProperty(testPlan.afterAllLabels);
-            return testPlan;
-        }));
-}
-
-async function loadSfdcCredential({ branch, projectId }) {
-    const branchData = await pRetry(() => getWithAuth(`/branch/branchData/${branch}`, {
-        projectId,
-    }), { retries: DEFAULT_REQUEST_RETRY });
-    return branchData?.sfdcCredential;
-}
-
-function loadTest({ testId, branch, projectId, skipSharedSteps = false, useBranchMap = true }) {
-    return pRetry(() => getWithAuth(`/test/${testId}`, {
-        projectId,
-        branch,
-        skipSharedSteps,
-        useBranchMap,
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function saveTestPlanResult(projectId, testPlanId, result) {
-    return pRetry(() => postAuth({ url: '/testPlan/result', body: { projectId, testPlanId, result } }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function updateTestStatus(projectId, executionId, testId, resultId, status, data, retries = DEFAULT_REQUEST_RETRY) {
-    return pRetry(() => putAuth('/result/run/test', {
-        runId: executionId,
-        testId,
-        resultId,
-        status,
-        projectId,
-        runnerVersion,
-        ...data,
-    }), { retries });
-}
-
-function updateExecutionTests(executionId, runnerStatuses, status, reason, success, startTime, endTime, projectId) {
-    return pRetry(() => putAuth('/result/run/tests', {
-        runId: executionId,
-        runnerStatuses,
-        status,
-        reason,
-        success,
-        startTime,
-        endTime,
-        projectId,
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function reportExecutionStarted({
-    executionId,
-    projectId,
-    labels,
-    startTime,
-    executions,
-    config,
-    resultLabels,
-    remoteRunId,
-    localRunUserId,
-    isLocalRun,
-    intersections,
-}) {
-    const isCiRun = require('../cli/isCiRun').isCi;
-    return postAuth({
-        timeout: 90000,
-        url: '/result/run',
-        body: {
-            runId: executionId,
-            projectId,
-            labels,
-            startTime,
-            execution: executions,
-            status: 'RUNNING',
-            config,
-            resultLabels,
-            remoteRunId,
-            intersections,
-            metadata: {
-                isCiRun,
-                localRunUserId,
-                isLocalRun,
-            },
-        },
-        retry: 3, // TODO: add a log in the callback
-    });
-}
-
-// eslint-disable-next-line default-param-last
-function reportExecutionFinished(status, executionId, projectId, success, tmsOptions = {}, remoteRunId, resultExtraData) {
-    const endTime = Date.now();
-
-    return pRetry(() => putAuth('/result/run', {
-        runId: executionId,
-        projectId,
-        endTime,
-        status,
-        success,
-        tmsOptions,
-        remoteRunId,
-        resultExtraData,
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-/**
- * @param {string} projectId
- * @param {string[]} names
- * @param {string[]} planIds
- * @param {string} branch
- * @param {import('../runOptions').RunnerOptions['intersections']} intersections
- * @returns {ReturnType<import('services/src/test-plan/service')['testPlan']['getTestPlanTestList']>}
- */
-async function getTestPlanTestList(projectId, names, planIds, branch, intersections) {
-    return pRetry(() => postAuth({
-        url: '/testPlan/list',
-        body: { projectId, names, planIds, branch, intersections },
-        // people who send insane lists get a timeout :(
-        timeout: 120000,
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-/**
- * @param {{
- *   projectId: string;
- *   labels: string[];
- *   testIds: string[];
- *   testNames: string[];
- *   testConfigNames?: string[];
- *   suiteNames: string[];
- *   suiteIds: string[];
- *   branch: string;
- *   rerunFailedByRunId?: string;
- *   testConfigIds?: string[];
- *   intersections: import('../runOptions').RunnerOptions['intersections'];
- * }} param0
- * @returns {Promise<import('services/src/suite/service').RunListResult>}
- */
-function getSuiteTestList({
-    projectId, labels, testIds, testNames, testConfigNames, suiteNames, suiteIds, branch, rerunFailedByRunId, testConfigIds, intersections,
-}) {
-    return pRetry(() => postAuth({
-        url: '/suite/v2/list',
-        body: {
-            projectId,
-            labels,
-            testIds,
-            testNames,
-            testConfigNames,
-            suiteNames,
-            suiteIds,
-            branch,
-            rerunFailedByRunId,
-            testConfigIds,
-            intersections,
-        },
-    }), { retries: DEFAULT_REQUEST_RETRY, factor: 1 });
-}
-
-async function getAppDetails({ appId, projectId }) {
-    try {
-        return await pRetry(() => getWithAuth(`/mobile-app/app/${appId}?projectId=${projectId}`), { retries: DEFAULT_REQUEST_RETRY, factor: 1 });
-    } catch (error) {
-        logger.error('failed getting application details', { appId, error });
-        return undefined;
-    }
-}
-
-function getUsageForCurrentBillingPeriod(projectId) {
-    return pRetry(() => getWithAuth(`/plan/project/${projectId}/usage-current-billing-period`), { retries: DEFAULT_REQUEST_RETRY })
-        .catch((error) => {
-            logger.error('failed getting usage for current billing period', { projectId, error });
-            return undefined;
-        });
-}
-
-function isTestResultCompleted(resultId, projectId, testRetryKey) {
-    return pRetry(() => getWithAuth(`/result/${resultId}/isComplete`, { projectId, testRetryKey }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function getTestResults(testId, resultId, projectId, branch) {
-    return pRetry(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }), { retries: DEFAULT_REQUEST_RETRY, factor: 1 });
-}
-
-function keepAliveGrid(projectId, slots) {
-    return postAuth({
-        url: `/grid/keep-alive?reqId=${utils.guid()}`,
-        body: { projectId, slots },
-        timeout: 10000,
-    });
-}
-
-function releaseGridSlot(companyId, projectId, slotId, gridId, browser) {
-    return postAuth({
-        url: `/grid/release?reqId=${utils.guid()}`,
-        body: {
-            companyId, projectId, slotId, gridId, browser,
-        },
-    });
-}
-
-function getHybridGridProvider(body) {
-    return postAuth({
-        url: '/grid/hybrid/provider',
-        body,
-    });
-}
-
-function getGridByName(companyId, projectId, gridName, browser, executionId) {
-    return pRetry(() => getWithAuth('/grid/name', {
-        companyId, projectId, name: gridName, browser, executionId, reqId: utils.guid(),
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function getGridById(companyId, projectId, gridId, browser, executionId) {
-    return pRetry(() => getWithAuth(`/grid/${gridId}`, { companyId, projectId, browser, executionId, reqId: utils.guid() }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-/**
- * @param {{ projectId: string; token: string; branchName: string; lightweightMode?: import('../runOptions').LightweightSettings; localGrid: boolean; }} param0
- * @returns {Promise<{
- *  authData: { token: string; refreshToken: string; uid: string; ngrokToken?: string; isNgrokWhitelisted?: boolean; };
- *  editorConfig: { editorUrl: string };
- *  companyByProjectId: Awaited<ReturnType<import('services/src/company/companyService')['getCompanyByProjectIdUsingCache']>>;
- *  projectById: NonNullable<Awaited<ReturnType<import('services/src/commons/testimCache')['project']['getById']>>>;
- *  allGrids: import('services/src/commons/mongo/models/grid').RawGrid[];
- *  branchName: string | import('services/src/commons/mongo/models/branchesData').RawBranchesData | null;
- * }>}
- */
-async function initializeUserWithAuth({ projectId, token, branchName, lightweightMode, localGrid }) {
-    try {
-        return await pRetry(() => httpRequest.post({
-            url: `${config.SERVICES_HOST}/executions/initialize`,
-            body: {
-                projectId,
-                token,
-                branchName: branchName || 'master',
-                lightweightMode,
-                localGrid,
-            },
-        }), { retries: DEFAULT_REQUEST_RETRY });
-    } catch (e) {
-        logger.error('error initializing info from server', e);
-        if (e?.message?.includes('Bad Request')) {
-            throw new ArgError(
-                'Error trying to retrieve CLI token. ' +
-                'Your CLI token and project might not match. ' +
-                'Please make sure to pass `--project` and `--token` that' +
-                ' match to each other or make sure they match in your ~/.testim file.');
-        }
-        if (e?.code?.includes('ENOTFOUND')) {
-            throw new ArgError('Due to network connectivity issues, Testim CLI has been unable to connect to the Testim backend.');
-        }
-        throw e;
-    }
-}
-
-async function getEditorUrl() {
-    if (config.EDITOR_URL) {
-        return config.EDITOR_URL;
-    }
-    try {
-        return await pRetry(() => getWithAuth('/system-info/editor-url'), {
-            retries: DEFAULT_REQUEST_RETRY,
-            onFailedAttempt: error => {
-                if (error.attemptNumber >= DEFAULT_REQUEST_RETRY) {
-                    throw error;
-                }
-            },
-        });
-    } catch (err) {
-        logger.error('cannot retrieve editor-url from server');
-        return 'https://app.testim.io';
-    }
-}
-
-function getAllGrids(companyId) {
-    return pRetry(() => getWithAuth('/grid', { companyId }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-const fetchLambdatestConfig = async () => pRetry(() => getWithAuth('/grid/lt/config'), { retries: DEFAULT_REQUEST_RETRY });
-
-const getLabFeaturesByProjectId = async (projectId) => pRetry(() => getWithAuth(`/labFeature/v2/project/${projectId}`), { retries: DEFAULT_REQUEST_RETRY });
-
-
-function getRealData(projectId, channel, query) {
-    return pRetry(() => getWithAuth(`/real-data/${channel}?${query}&projectId=${projectId}`), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function updateTestResult(projectId, resultId, testId, testResult, remoteRunId) {
-    return pRetry(() => postAuth({
-        url: '/result/test',
-        body: {
-            projectId,
-            resultId,
-            testId,
-            testResult,
-            remoteRunId,
-        },
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function clearTestResult(projectId, resultId, testId, testResult) {
-    return pRetry(() => postAuth({
-        url: '/result/test/clear',
-        body: {
-            projectId,
-            resultId,
-            testId,
-            testResult,
-        },
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-function saveRemoteStep(projectId, resultId, stepId, remoteStep) {
-    return pRetry(() => postAuth({
-        url: '/remoteStep',
-        body: {
-            projectId,
-            resultId,
-            stepId,
-            remoteStep,
-        },
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-/** @param {string} uri */
-function relativize(uri) {
-    return uri.startsWith('/') ? uri : `/${uri}`;
-}
-
-/**
- * @param {string} filePath
- * @param {string} bucket
- * @param {string} projectId
- */
-function getStorageRelativePath(filePath, bucket, projectId) {
-    let fullPath = relativize(filePath);
-    if (projectId) {
-        fullPath = `/${projectId}${fullPath}`;
-    }
-    if (bucket) {
-        fullPath = `/${bucket}${fullPath}`;
-    }
-
-    return fullPath;
-}
-
-/**
- * @param {string} projectId
- * @param {string} testId
- * @param {string} testResultId
- * @param {*} content
- * @param {string} subType
- * @param {string} mimeType
- */
-async function uploadArtifact(projectId, testId, testResultId, content, subType, mimeType = 'application/octet-stream') {
-    let fileSuffix = null;
-    if (mimeType === 'application/json') {
-        fileSuffix = '.json';
-    }
-    const fileName = `${subType}_${utils.guid()}${fileSuffix || ''}`;
-    const path = `${testId}/${testResultId}/${fileName}`;
-    const storagePath = getStorageRelativePath(path, 'test-result-artifacts', projectId);
-
-    const buffer = Buffer.from(pako.gzip(content, {
-        level: 3, // sufficient time/size ratio.
-    }));
-
-    const files = {
-        file: {
-            fileName,
-            buffer,
-        },
-    };
-
-    await pRetry(
-        () => postAuthFormData(`/storage${storagePath}`, {}, files, { 'X-Asset-Encoding': 'gzip' }),
-        { retries: DEFAULT_REQUEST_RETRY, factor: 1 },
-    );
-    return storagePath;
-}
-
-const uploadRunDataArtifact = _.memoize(async (projectId, testId, testResultId, runData) => {
-    if (_.isEmpty(runData)) {
-        return undefined;
-    }
-    return await uploadArtifact(projectId, testId, testResultId, JSON.stringify(runData), 'test-run-data', 'application/json');
-}, (projectId, testId, testResultId, runData) => `${hash(runData)}:${testId}:${testResultId}`);
-
-const updateTestDataArtifact = _.memoize(async (projectId, testId, testResultId, testData, projectDefaults) => {
-    if (_.isEmpty(testData)) {
-        return undefined;
-    }
-    const removeHiddenParamsInTestData = () => {
-        const testDataValueClone = _.clone(testData);
-        if (projectDefaults?.hiddenParams) {
-            const { hiddenParams } = projectDefaults;
-            (hiddenParams || []).forEach((param) => {
-                if (testDataValueClone[param]) {
-                    testDataValueClone[param] = constants.test.HIDDEN_PARAM;
-                }
-            });
-        }
-        return testDataValueClone;
-    };
-
-    return await uploadArtifact(projectId, testId, testResultId, JSON.stringify(removeHiddenParamsInTestData(testData)), 'test-test-data', 'application/json');
-}, (projectId, testId, testResultId, testData) => `${hash(testData)}:${testId}:${testResultId}`);
-
-function addTestRetry({
-    projectId,
-    runId,
-    testId,
-    newResultId,
-    originalTestResultId,
-    previousTestResultId,
-    testResult,
-}) {
-    return pRetry(() => postAuth({
-        url: '/result/test/retry',
-        body: {
-            projectId,
-            newResultId,
-            originalTestResultId,
-            previousTestResultId,
-            testId,
-            runId,
-            testResult,
-        },
-    }), { retries: DEFAULT_REQUEST_RETRY });
-}
-
-/**
- * @param {string} projectId
- * @returns {Promise<import('../../../clickim/src/common/api/testimApplitoolsApi').ApplitoolsIntegrationData>}
- */
-async function getApplitoolsIntegrationData(projectId) {
-    try {
-        return await getWithAuth(`/integration/applitools/v3/connected?projectId=${projectId}`);
-    } catch (err) {
-        logger.warn('could\'nt get applitools integration data.', { err });
-        return {};
-    }
-}
-
-
-/**
- * @param {string} companyId
- * @param {string[]} routes
- * @returns {Promise<{ _id?: string; token?: string; routesMapping?: { [k: string]: string; } }>}
- */
-async function getCloudflareTunnel(companyId, routes) {
-    try {
-        return await putAuth('/tunnel', { companyId, routes });
-    } catch (err) {
-        logger.warn('could\'nt get tunnel.', { err });
-        return {};
-    }
-}
-/**
- * @param {string} companyId
- * @param {string} tunnelId
- * @returns {Promise<void>}
- */
-async function forceUpdateCloudflareTunnelRoutes(companyId, tunnelId) {
-    try {
-        return await postAuth({ url: `/tunnel/${tunnelId}`, body: { companyId } });
-    } catch (err) {
-        logger.warn('could\'nt get tunnel.', { err });
-        return undefined;
-    }
-}
-/**
- * @param {string} companyId
- * @param {string} tunnelId
- * @returns {Promise<void>}
- */
-async function deleteCloudflareTunnel(companyId, tunnelId) {
-    try {
-        return await deleteAuth(`/tunnel/${tunnelId}`, { companyId });
-    } catch (err) {
-        logger.warn('could\'nt get tunnel.', { err });
-        return {};
-    }
-}
-
-function updateRemoteRunFailure(body) {
-    return httpRequest.post({ url: `${config.SERVICES_HOST}/result/remoteRunFailure`, body });
-}
-
-/**
- * @param {string} projectType
- * @param {string} gridId
- * @param {string} companyId
- * @param {string} selectors
- * @return {Promise<Array[import('../../../services/src/grid/mobileGridService').MobileDevice] | null>}
- */
-
-async function getMobileDevicesFromGrid({ projectId, projectType, gridId, companyId, selectors }) {
-    let url = `${GRID_PATH}/mobileDevices/${gridId}/${companyId}?projectType=${projectType}`;
-    url = selectors ? `${url}&selectors=${encodeURIComponent(selectors)}` : url;
-    try {
-        return await pRetry(() => getWithAuth(url, { projectId }), { retries: DEFAULT_REQUEST_RETRY });
-    } catch (err) {
-        logger.warn('could\'nt get devices from headspin grid.', { err });
-        return null;
-    }
-}
-
-module.exports = {
-    getAppDetails,
-    getS3Artifact,
-    getTestPlan,
-    saveTestPlanResult,
-    updateTestStatus,
-    updateExecutionTests,
-    reportExecutionStarted,
-    reportExecutionFinished,
-    getTestPlanTestList,
-    getSuiteTestList,
-    getUsageForCurrentBillingPeriod,
-    getTestResults,
-    getGridByName,
-    releaseGridSlot,
-    keepAliveGrid,
-    getGridById,
-    getAllGrids,
-    fetchLambdatestConfig,
-    getRealData,
-    updateTestResult,
-    clearTestResult,
-    saveRemoteStep,
-    getEditorUrl,
-    getLabFeaturesByProjectId,
-    uploadRunDataArtifact,
-    updateTestDataArtifact,
-    initializeUserWithAuth,
-    addTestRetry,
-    getHybridGridProvider,
-    loadSfdcCredential,
-    loadTest,
-    isTestResultCompleted,
-    getApplitoolsIntegrationData,
-    getCloudflareTunnel,
-    forceUpdateCloudflareTunnelRoutes,
-    deleteCloudflareTunnel,
-    updateRemoteRunFailure,
-    getMobileDevicesFromGrid,
-};

package/commons/testimTunnel.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const ora = require('ora');
-
-const LambdatestService = require('../services/lambdatestService');
-const processHandler = require('../processHandler');
-const testimCustomToken = require('./testimCustomToken');
-const { gridTypes } = require('./constants');
-const testimNgrok = require('./testimNgrok');
-const testimCloudflare = require('./testimCloudflare');
-const logger = require('./logger').getLogger('tunnel');
-
-const shouldUseLambdatestTunnel = options => [gridTypes.LAMBDATEST, gridTypes.HYBRID].includes(options.gridData && options.gridData.type) && options.gridData.tunnel === 'lambdatest';
-const shouldUseCloudflareTunnel = options => options.tunnelRoutes || (options.gridData && options.gridData.type === gridTypes.HYBRID && options.gridData.tunnel === 'cloudflare');
-
-const connect = async (options) => {
-    if (!options.tunnel) {
-        return;
-    }
-
-    const authData = testimCustomToken.getTokenV3UserData();
-    let spinner;
-    try {
-        if (shouldUseLambdatestTunnel(options)) {
-            spinner = ora('Starting testim lambdatest tunnel...').start();
-            await LambdatestService.connectTunnel(options);
-        } else if (shouldUseCloudflareTunnel(options)) {
-            spinner = ora('Starting testim cloudflare tunnel...').start();
-            await testimCloudflare.connectTunnel(options);
-        } else {
-            spinner = ora('Starting testim ngrok tunnel...').start();
-            await testimNgrok.connectTunnel(options, authData);
-        }
-        spinner.succeed();
-    } catch (err) {
-        const msg = 'Failed to start tunnel. Please contact support@testim.io';
-        logger.error('Failed to open tunnel', { err });
-        spinner.fail(msg);
-        throw new Error(msg);
-    }
-};
-
-const disconnect = async (options) => {
-    if (!options.tunnel) {
-        return;
-    }
-
-    try {
-        if (shouldUseLambdatestTunnel(options)) {
-            await LambdatestService.disconnectTunnel(options);
-        } else if (options.tunnelRoutes) {
-            await testimCloudflare.disconnectTunnel(options);
-        } else {
-            await testimNgrok.disconnectTunnel(options);
-        }
-    } catch (err) {
-        const msg = 'catch error - failed to close tunnel';
-        logger.error(msg, { err });
-        throw new Error(msg);
-    }
-};
-
-const serveTunneling = async (options, waitFor = new Promise(() => { /* avoid exiting process */ })) => {
-    await module.exports.connect(options);
-    processHandler.registerExitHook(() => module.exports.disconnect(options));
-    return await waitFor;
-};
-
-module.exports = {
-    connect,
-    disconnect,
-    serveTunneling,
-};