@testim/testim-cli/commons/testimServicesApi.js

'use strict';

const pako = require('pako');
const _ = require('lodash');
const testimCustomToken = require('./testimCustomToken');
const constants = require('./constants');
const Promise = require('bluebird');
const utils = require('../utils.js');
const config = require('./config');
const httpRequest = require('./httpRequest');

const runnerVersion = utils.getRunnerVersion();
const logger = require('./logger').getLogger('testim service api');
const hash = require('object-hash');
const { ArgError } = require('../errors');

const DEFAULT_REQUEST_RETRY = 3;

function getTokenHeader() {
    return testimCustomToken.getCustomTokenV3()
        .then(brearToken => {
            if (!brearToken) {
                return Promise.reject(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,
            });
        });
}

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 getTextWithAuth(url, query) {
    return getTokenHeader()
        .then(headers => httpRequest.getText(`${config.SERVICES_HOST}${url || ''}`, query, headers));
}

function getWithAuth(url, query, options) {
    return getTokenHeader()
        .then(headers => httpRequest.get(`${config.SERVICES_HOST}${url || ''}`, query, headers, undefined, options));
}

function getS3Artifact(url) {
    return utils.runWithRetries(() => getWithAuth(`/storage${url}`, null, { isBinary: true }));
}

function getTestPlan(projectId, testPlanNames) {
    return utils.runWithRetries(() => getWithAuth('/testPlan', { projectId, name: testPlanNames.join(',') }))
        .then(body => body.map(testPlan => {
            testPlan.testConfigIds = testPlan.testConfigIds ? JSON.parse(testPlan.testConfigIds) : [];
            testPlan.beforeAllLabels = testPlan.beforeAllLabels ? JSON.parse(testPlan.beforeAllLabels) : [];
            testPlan.testLabels = testPlan.testLabels ? JSON.parse(testPlan.testLabels) : [];
            testPlan.afterAllLabels = testPlan.afterAllLabels ? JSON.parse(testPlan.afterAllLabels) : [];
            return testPlan;
        }));
}

function saveTestPlanResult(projectId, testPlanId, result) {
    return utils.runWithRetries(() => postAuth({ url: '/testPlan/result', body: { projectId, testPlanId, result } }));
}

function updateTestStatus(status, executionId, testId, resultId, startTime, endTime, success, failureReason, config, projectId, remoteRunId) {
    return utils.runWithRetries(() => putAuth('/result/run/test', {
        runId: executionId,
        testId,
        startTime,
        endTime,
        success,
        failureReason,
        resultId,
        status,
        config,
        projectId,
        runnerVersion,
        remoteRunId,
    }), DEFAULT_REQUEST_RETRY);
}

function updateExecutionTests(executionId, runnerStatuses, status, reason, success, startTime, endTime, projectId) {
    return utils.runWithRetries(() => putAuth('/result/run/tests', {
        runId: executionId,
        runnerStatuses,
        status,
        reason,
        success,
        startTime,
        endTime,
        projectId,
    }), DEFAULT_REQUEST_RETRY);
}

function reportExecutionStarted(executionId, projectId, labels, startTime, executions, config, resultLabels, remoteRunId) {
    const isCiRun = require('../cli/isCiRun').isCi;
    return postAuth({
        url: '/result/run',
        body: {
            runId: executionId,
            projectId,
            labels,
            startTime,
            execution: executions,
            status: 'RUNNING',
            config,
            resultLabels,
            remoteRunId,
            metadata: {
                isCiRun,
            },
        },
        retry: 3,
    });
}

function reportExecutionFinished(status, executionId, projectId, success, suppressTmsReporting = false, tmsRunId = '', remoteRunId) {
    const endTime = Date.now();

    return utils.runWithRetries(() => putAuth('/result/run', {
        runId: executionId,
        projectId,
        endTime,
        status,
        success,
        suppressTmsReporting,
        tmsRunId,
        remoteRunId,
    }), DEFAULT_REQUEST_RETRY);
}

function getBranchData(projectId, branchName) {
    return utils.runWithRetries(() => getWithAuth(`/branch/branchData/${encodeURIComponent(branchName)}`, { projectId }));
}

function getUserDetails(userId) {
    return utils.runWithRetries(() => getWithAuth(`/user/user/${userId}`));
}

function getTestPlanTestList(projectId, names, branch) {
    return utils.runWithRetries(() => postAuth({
        url: '/testPlan/list',
        body: { projectId, names, branch },
    }));
}

function getSuiteTestList(projectId, labels, testIds, names, testConfigNames, suites, branch, rerunFailedByRunId, testConfigIds) {
    return utils.runWithRetries(() => postAuth({
        url: '/suite/v2/list',
        body: {
            projectId,
            labels,
            testIds,
            names,
            testConfigNames,
            suites,
            branch,
            rerunFailedByRunId,
            testConfigIds,
        },
    }));
}

function getCurrentPeriodTestExecutionMongo(projectId, plan) {
    function getBilingStartDate(subscriptionId, projectId) {
        return utils.runWithRetries(() => getTextWithAuth('/plan/project/billing-period-start-date', {
            subscriptionId,
            projectId,
        }))
            .then(billingPeriod => (Number(billingPeriod)));
    }

    function count(projectId, startTime) {
        return utils.runWithRetries(() => getWithAuth('/executions/v2/project/count', { projectId, startTime }))
            .catch(() => ({}));
    }

    return getBilingStartDate((plan || {}).subscriptionId, projectId).then(billingPeriod => count(projectId, billingPeriod));
}

function getOwnerUserIdMongo(projectId) {
    return utils.runWithRetries(() => getWithAuth('/v2/project/owner', { projectId }))
        .then(ownerUser => (ownerUser || {}).uid);
}

function getProjectPlanMongo(projectId) {
    return utils.runWithRetries(() => getWithAuth('/plan/current-plan', { projectId }));
}

function getTestResults(testId, resultId, projectId, branch) {
    return utils.runWithRetries(() => getWithAuth(`/test/v2/${testId}/result/${resultId}`, { projectId, branch }));
}

function keepAliveGrid(projectId, slots) {
    return postAuth({
        url: '/grid/keep-alive',
        body: { projectId, slots },
        timeout: 10000,
    });
}

function releaseGridSlot(projectId, slotId, gridId, browser) {
    return postAuth({
        url: '/grid/release',
        body: {
            projectId, slotId, gridId, browser,
        },
    });
}

function getGridByProject(projectId, gridName, browser, executionId) {
    return utils.runWithRetries(() => getWithAuth('/grid/name', {
        projectId, name: gridName, browser, executionId,
    }));
}

function getGridById(projectId, gridId, browser, executionId) {
    return utils.runWithRetries(() => getWithAuth(`/grid/${gridId}`, { projectId, browser, executionId }));
}

function getCompanyByProjectId(projectId) {
    return utils.runWithRetries(() => getWithAuth(`/company/company/${projectId}`));
}

function getProject(projectId) {
    return utils.runWithRetries(() => getWithAuth(`/v2/project/project?projectId=${projectId}`));
}

async function initializeUserWithAuth({ projectId, token, branchName }) {
    try {
        return await utils.runWithRetries(() => httpRequest.post({
            url: `${config.SERVICES_HOST}/executions/initialize`,
            body: {
                projectId,
                token,
                branchName: branchName || 'master',
            },
        }));
    } catch (e) {
        logger.error('error initializing info from server', e);
        if (e && e.message && 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 && e.code && 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 utils.runWithRetries(() => getWithAuth('/system-info/editor-url'));
    } catch (err) {
        logger.error('cannot retrieve editor-url from server');
        return 'https://app.testim.io';
    }
}

function getAllGrids(companyId) {
    return utils.runWithRetries(() => getWithAuth('/grid', { companyId }));
}

function getAppUploadUrl(projectId, projectArn, appName) {
    return utils.runWithRetries(() => postAuth({
        url: '/deviceFarm/app',
        body: {
            projectId,
            projectArn,
            appName,
        },
    }));
}

function createDeviceFarmRun(companyId, projectId, projectArn, appArn, configuration, branch, executionId, env, remoteRunObject) {
    return postAuth({
        url: '/deviceFarm/run',
        body: {
            companyId,
            projectId,
            projectArn,
            appArn,
            configuration,
            branch,
            executionId,
            env,
            remoteRunObject,
        },
        timeout: 30000,
    });
}

function getDeviceFarmRun(projectId, runArn) {
    return getWithAuth(`/deviceFarm/run?projectId=${projectId}&runArn=${runArn}`);
}

function getRealData(projectId, channel, query) {
    return utils.runWithRetries(() => getWithAuth(`/real-data/${channel}?${query}&projectId=${projectId}`));
}

function updateTestResult(projectId, resultId, testId, testResult, remoteRunId) {
    return utils.runWithRetries(() => postAuth({
        url: '/result/test',
        body: {
            projectId,
            resultId,
            testId,
            testResult,
            remoteRunId,
        },
    }));
}

function clearTestResult(projectId, resultId, testId, testResult) {
    return utils.runWithRetries(() => postAuth({
        url: '/result/test/clear',
        body: {
            projectId,
            resultId,
            testId,
            testResult,
        },
    }));
}

function saveRemoteStep(projectId, resultId, stepId, remoteStep) {
    return utils.runWithRetries(() => postAuth({
        url: '/remoteStep',
        body: {
            projectId,
            resultId,
            stepId,
            remoteStep,
        },
    }));
}

function relativize(uri) {
    return uri.startsWith('/') ? uri : `/${uri}`;
}

function getStorageRelativePath(filePath, bucket, projectId) {
    let fullPath = relativize(filePath);
    if (projectId) {
        fullPath = `/${projectId}${fullPath}`;
    }
    if (bucket) {
        fullPath = `/${bucket}${fullPath}`;
    }

    return fullPath;
}

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,
        },
    };

    return utils.runWithRetries(() => postAuthFormData(`/storage${storagePath}`, {}, files, { 'Content-Encoding': 'gzip' }))
        .then(() => 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 && 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}`);

module.exports = {
    getS3Artifact,
    getTestPlan,
    saveTestPlanResult,
    updateTestStatus,
    updateExecutionTests,
    reportExecutionStarted,
    reportExecutionFinished,
    getBranchData,
    getUserDetails,
    getTestPlanTestList,
    getSuiteTestList,
    getCompanyByProjectId,
    getProject,
    getOwnerUserIdMongo,
    getProjectPlanMongo,
    getCurrentPeriodTestExecutionMongo,
    getTestResults,
    getGridByProject,
    releaseGridSlot,
    keepAliveGrid,
    getGridById,
    getAllGrids,
    getAppUploadUrl,
    createDeviceFarmRun,
    getDeviceFarmRun,
    getRealData,
    updateTestResult,
    clearTestResult,
    saveRemoteStep,
    getEditorUrl,
    uploadRunDataArtifact: Promise.method(uploadRunDataArtifact),
    updateTestDataArtifact: Promise.method(updateTestDataArtifact),
    initializeUserWithAuth: Promise.method(initializeUserWithAuth),
};