@testim/testim-cli 3.289.0 → 3.290.0

package/agent/routers/codim/router.js

@@ -1,69 +0,0 @@
-'use strict';
-
-const express = require('express');
-
-const router = express.Router();
-const logger = require('../../../commons/logger').getLogger('codim-router');
-
-const {
-    findTests,
-    getLocalLocators,
-    getLocalLocatorContents,
-    saveTest,
-    saveLocators,
-    compileFunctionsLibrary,
-} = require('./service');
-
-
-router.get('/tests', async (req, res) => {
-    const tests = await findTests();
-    res.json({ tests, success: true });
-});
-router.get('/locators', async (req, res) => {
-    const locators = await getLocalLocators();
-    const contents = await getLocalLocatorContents(locators, req.query.full);
-    res.json({ locators, contents, success: true });
-});
-router.post('/locators', async (req, res) => {
-    if (!req.body) {
-        res.status(400).send({ success: false, reason: 'missing body' });
-        return;
-    }
-    if (!req.body.locators) {
-        res.status(400).send({ success: false, reason: 'missing locators' });
-        return;
-    }
-
-    const { locators, mergeIntoExisting } = req.body;
-
-    await saveLocators(locators, { mergeIntoExisting: mergeIntoExisting || false });
-    res.status(200).send({ success: true });
-});
-
-router.get('/compile', async (req, res) => {
-    try {
-        const code = await compileFunctionsLibrary(req.body.name);
-        res.send({ success: true, code });
-    } catch (e) {
-        logger.error(e);
-        res.json({ success: false, reason: e.message });
-    }
-});
-
-router.post('/saveTest', async (req, res) => {
-    if (!req.body) {
-        res.status(400).send({ success: false, reason: 'missing body' });
-        return;
-    }
-    try {
-        await saveTest(req.body);
-        res.send({ success: true });
-    } catch (e) {
-        res.json({ success: false, reason: e.message });
-        logger.error(e);
-    }
-});
-
-
-
-module.exports.router = router;

package/agent/routers/codim/router.test.js

@@ -1,60 +0,0 @@
-'use strict';
-
-const router = require('./router');
-const path = require('path');
-const os = require('os');
-const compression = require('compression');
-const express = require('express');
-const bodyParser = require('body-parser');
-const superagent = require('superagent');
-const fs = require('fs');
-const { expect } = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
-
-const app = express();
-
-app.use(bodyParser.urlencoded({ extended: false, limit: '50mb' }));
-app.use(compression());
-app.use(bodyParser.json({ limit: '50mb' }));
-
-app.use('/files', router.router);
-
-describe('codim router', () => {
-    let listener;
-    async function saveLocators(locatorsObject) {
-        const request = superagent.post(`http://localhost:${listener.address().port}/files/locators`).send(locatorsObject);
-        await request;
-    }
-
-    async function loadLocators() {
-        const request = superagent.get(`http://localhost:${listener.address().port}/files/locators`);
-        const response = await request;
-        return JSON.parse(response.text);
-    }
-
-    let tmpDir;
-
-    before((done) => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tdk-test-'));
-        process.chdir(tmpDir);
-        listener = app.listen(0, () => done());
-    });
-
-    after(async () => {
-        await fs.promises.unlink(tmpDir).catch(() => {});
-    });
-
-    it('saves locators', async () => {
-        await saveLocators({
-            locators: [{ id: 'foo', name: 'foo', body: { internal: 'bar' } }],
-            mergeIntoExisting: false,
-        });
-        const locators = await loadLocators();
-        expect(locators).to.deep.eq({
-            contents: {},
-            locators: {
-                foo: 'foo',
-            },
-            success: true,
-        });
-    });
-});

package/agent/routers/codim/service.js

@@ -1,193 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const path = require('path');
-const fsPromises = require('fs/promises');
-const { fromPairs } = require('lodash');
-const { buildCodeTests } = require('../../../runners/buildCodeTests');
-const { AbortError } = require('../../../commons/AbortError');
-
-const findTestFolder = _.memoize(async (fromFolder) => {
-    const files = await fsPromises.readdir(fromFolder);
-    // this is either invoked by running the Testim CLI from inside the tests folder or from inside the `init` folder
-    // so deal with the case we're inside tests.
-    const isInProjectFolder = files.includes('tests') && (await fsPromises.stat(path.join(fromFolder, 'tests'))).isDirectory();
-    if (isInProjectFolder) {
-        return path.join(fromFolder, 'tests');
-    }
-    return fromFolder;
-});
-
-async function getLocalLocators() {
-    const folder = await findTestFolder(process.cwd());
-    const locatorsFilePath = path.join(folder, 'locators', 'locators.js');
-    function parseLocators(buffer) {
-        // remove require calls to not read all the locators into memory when evaluating
-        // eslint-disable-next-line no-eval
-        return eval(buffer.toString().replace(/require/g, '(x => /locator\.(.*)\.json/.exec(x)[1])'));
-    }
-    const locators = await fsPromises.readFile(locatorsFilePath).then(parseLocators, () => ({}));
-    return _(Object.keys(locators)).map((id) => {
-        const escapedId = id.replace(/"/g, '\\"');
-        return [escapedId, locators[id]];
-    }).fromPairs().value();
-}
-
-async function findTests(folder = process.cwd()) {
-    const testFolder = await findTestFolder(folder);
-    const filesWithStat = await fsPromises.readdir(testFolder, { withFileTypes: true });
-
-    // things we know are not tests but end in js
-    const excluded = ['webpack.config.js', 'tsconfig.js', '.DS_Store', 'functions.js'];
-    const excludedFileTypes = ['.html', '.json'];
-    return filesWithStat
-        .filter(x =>
-            !excluded.includes(x.name) &&
-            !excludedFileTypes.some(type => x.name.endsWith(type)) &&
-            x.isFile() &&
-            !x.name.startsWith('.'),
-        )
-        .map(x => x.name);
-}
-
-/**
- * @param {Record<string, object | Promise<object>>} propsObject
- * @returns {Promise<Record<string, object>>}
- * */
-async function promiseFromProps(propsObject) {
-    const entries = Object.entries(propsObject);
-    const values = entries.map(([, value]) => value);
-    const resolvedValues = await Promise.all(values);
-    for (let i = 0; i < resolvedValues.length; i++) {
-        entries[i][1] = resolvedValues[i];
-    }
-    return Object.fromEntries(entries);
-}
-
-async function getLocalLocatorContents(locators, full = false, originFolder = process.cwd()) {
-    const props = {};
-    if (full) {
-        const folder = await findTestFolder(originFolder);
-        for (const key of Object.values(locators)) {
-            props[key] = fsPromises.readFile(path.join(folder, 'locators', `locator.${key}.json`)).then(JSON.parse);
-        }
-    }
-    try {
-        const contents = await promiseFromProps(props);
-        return contents;
-    } catch (e) {
-        // eslint-disable-next-line no-console
-        console.error(e);
-        return {};
-    }
-}
-async function saveTest({
-    body, name, locators, language = 'javascript',
-}) {
-    const folder = await findTestFolder(process.cwd());
-    const locatorsFilePath = path.join(folder, 'locators', 'locators.js');
-    let filename = path.join(folder, name);
-    if (!filename.startsWith(folder)) {
-        throw new Error('A test name must be a valid file name and inside the tests directory');
-    }
-    if (language === 'javascript') {
-        if (filename.endsWith('.js') && !filename.endsWith('.test.js')) {
-            filename = `${filename.substr(0, filename.length - 3)}.test.js`;
-        } else if (!filename.endsWith('.test.js')) {
-            filename += '.test.js';
-        }
-    } else if (filename.endsWith('.ts') && !filename.endsWith('.test.ts')) {
-        filename = `${filename.substr(0, filename.length - 3)}.test.ts`;
-    } else if (!filename.endsWith('.test.ts')) {
-        filename = `${filename}.test.ts`;
-    }
-    if (filename.endsWith('locators/locators.js')) {
-        throw new Error('Cannot override locators file from the internet as it is evaluated by the runner');
-    }
-    await fsPromises.writeFile(filename, body);
-    await fsPromises.mkdir(path.join(folder, 'locators')).catch(() => {});
-    for (const { id, body } of locators) {
-        await fsPromises.writeFile(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify(body));
-    }
-    const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));
-    const localLocatorMap = await getLocalLocators();
-    Object.assign(localLocatorMap, locatorMap);
-    await writeLocators(locatorsFilePath, localLocatorMap);
-}
-async function writeLocators(locatorsFilePath, locatorMap) {
-    let content = 'module.exports = {\n';
-    for (const [key, value] of Object.entries(locatorMap)) {
-        content += `  "${key}": require('./locator.${value}.json'),\n`;
-    }
-    content += '};';
-    await fsPromises.writeFile(locatorsFilePath, content);
-}
-async function saveLocators(locators, { mergeIntoExisting } = { mergeIntoExisting: false }) {
-    const folder = await findTestFolder(process.cwd());
-    const locatorsFilePath = path.join(folder, 'locators', 'locators.js');
-    await fsPromises.mkdir(path.join(folder, 'locators')).catch(() => {});
-
-    for (const { name, id, elementLocator } of locators) {
-        await fsPromises.writeFile(path.join(folder, 'locators', `locator.${id}.json`), JSON.stringify({ name, id, elementLocator }));
-    }
-    const locatorMap = fromPairs(locators.map(({ name, id }) => [name, id]));
-    if (mergeIntoExisting) {
-        const localLocatorMap = await getLocalLocators();
-        Object.assign(locatorMap, localLocatorMap);
-    }
-
-    await writeLocators(locatorsFilePath, locatorMap);
-}
-
-async function compileFunctionsLibrary({ fileSystem, bypassWebpack } = {}, optionalAbortSignal = undefined) {
-    const folder = await findTestFolder(process.cwd());
-    if (optionalAbortSignal?.aborted) {
-        throw new AbortError();
-    }
-
-    const functionsFile = path.join(folder, 'functions.js');
-    if (bypassWebpack?.testim) {
-        const Module = require('module');
-        // attempt to require without webpack compile - useful for puppeteer/selenium hybrid
-        const originalRequire = Module.prototype.require;
-        Module.prototype.require = function requireThatOverridesTestimTDK(id) {
-            if (id === 'testim') {
-                return bypassWebpack.testim;
-            }
-            // eslint-disable-next-line prefer-rest-params
-            return originalRequire.apply(this, arguments);
-        };
-        try {
-            // delete references to the old __testim from previous invocations
-            delete require.cache[require.resolve(functionsFile)];
-            const functions = require(functionsFile); // eslint-disable-line import/no-dynamic-require
-            // asynchronous require not supported - is this fine?
-            return functions;
-        } finally {
-            Module.prototype.require = originalRequire;
-        }
-    }
-    const functionsAsAWebpackModule = await buildCodeTests([functionsFile], {
-        output: {
-            libraryTarget: 'umd',
-            library: 'tdk',
-            globalObject: 'globalThis',
-        },
-        cache: {
-            type: 'memory',
-        },
-        mode: 'development', // better debugging
-    }, {}, fileSystem, optionalAbortSignal);
-    // we always compile a single suite and a single file here
-    return functionsAsAWebpackModule.tests[0][0].code;
-}
-
-module.exports = {
-    findTestFolder,
-    findTests,
-    getLocalLocators,
-    getLocalLocatorContents,
-    saveTest,
-    saveLocators,
-    compileFunctionsLibrary,
-};

package/agent/routers/general/index.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const { getPackageVersion } = require('../../../testimNpmDriver');
-const { doLogin } = require('../../../credentialsManager');
-const { getStartedWithStart } = require('../../../cliAgentMode');
-
-module.exports = (app) => {
-    /**
-     * root endpoint
-     */
-    app.get('/', (req, res) => {
-        const isStartMode = getStartedWithStart();
-
-        return res.status(200).json({ success: true, isTestimAgent: true, startMode: isStartMode });
-    });
-
-    /**
-     * Get version route
-     */
-    app.get('/version', (req, res) => {
-        res.status(200).json({
-            node: process.version,
-            app: getPackageVersion(),
-        });
-    });
-
-    app.get('/loginInfo', (req, res) => {
-        try {
-            const projects = JSON.parse(Buffer.from(req.query.info, 'base64').toString());
-            doLogin({ overwriteExisting: false, projects });
-            res.status(200).end();
-        } catch (err) {
-            res.status(400).end();
-        }
-    });
-};

package/agent/routers/hybrid/registerRoutes.js

@@ -1,81 +0,0 @@
-'use strict';
-
-const service = require('../../../stepPlayers/hybridStepPlayback');
-const express = require('express');
-const lazyRequire = require('../../../commons/lazyRequire');
-const logger = require('../../../commons/logger').getLogger('hybrid-router');
-
-/**
- * @param {{
-    webdriverApi: import("../../../player/WebdriverioWebDriverApi")
-}} [testimStandaloneBrowser]
- */
-module.exports.hybridRoutes = function hybridRoutes(testimStandaloneBrowser) {
-    const router = express.Router();
-
-    router.post('/run', (req, res) => {
-        if (!req.body || !req.body.step) {
-            res.status(400).send({
-                error: 'Missing step',
-            });
-            return;
-        }
-
-        const {
-            step,
-            context,
-            loginData, // is this safe to pass here?
-        } = req.body;
-        if (!testimStandaloneBrowser.webdriverApi) {
-            res.status(503).send({ success: false, reason: 'Testim Agent was not started with Testim Start.' });
-        }
-
-        // The step run might take very long time, and it will still be valid
-        // so we set here unlimited timeout
-        req.setTimeout(0);
-
-        service.execute(
-            step,
-            context,
-            testimStandaloneBrowser.webdriverApi,
-            loginData,
-            undefined, // don't pass frameManager,
-            'agent'
-        ).then((result) => {
-            res.status(200).send(result);
-        }).catch(e => {
-            logger.error('failed to run hybrid code', { e });
-            res.status(500).send(Object.assign({ success: false, error: e }));
-        });
-    });
-
-    router.post('/abort', (req, res) => {
-        if (!req.body || !req.body.stepResultId) {
-            res.status(400).send({
-                error: 'missing stepResultId',
-            });
-
-            return;
-        }
-
-        try {
-            service.abort(req.body.stepResultId);
-            res.status(204).end();
-        } catch (e) {
-            if (e && e.message === 'No such stepResultId') {
-                res.status(400).send({
-                    error: 'No such stepResultId',
-                });
-                return;
-            }
-
-            logger.error('hybrid code abort unexpected error', { e });
-            res.status(500).send({
-                error: 'unexpected error',
-                info: `${e ? e.message : 'N/A'}`,
-            });
-        }
-    });
-
-    return router;
-};

package/agent/routers/index.js

@@ -1,56 +0,0 @@
-'use strict';
-
-const compression = require('compression');
-const express = require('express');
-const bodyParser = require('body-parser');
-const cors = require('cors');
-const { IS_ON_PREM, DISABLE_AGENT_ORIGIN_CHECK } = require('../../commons/config');
-
-
-module.exports = function (beforeMiddleware, standaloneBrowserInfo) {
-    const app = express();
-    beforeMiddleware(app);
-
-    // view engine setup
-    app.use(bodyParser.urlencoded({ extended: false, limit: '50mb' }));
-    app.use(compression());
-    app.use(bodyParser.json({ limit: '50mb' }));
-
-    /**
-     * set cors options
-     */
-
-    const whitelist = ['http://localhost:3000', 'https://app.testim.io', 'https://staging.testim.io', 'https://playground.testim.io',
-        'https://app.staging.testim.cc', 'chrome-extension://pebeiooilphfmbohdbhbomomkkoghoia', 'https://tta-crm.tricentis.com'];
-    const corsOptions = {
-        methods: ['GET', 'PUT', 'POST', 'DELETE', 'OPTIONS'],
-        allowedHeaders: ['Content-Type', 'Authorization'],
-        credentials: true,
-        maxAge: 86400,
-        origin: (IS_ON_PREM || DISABLE_AGENT_ORIGIN_CHECK) ? '*' : whitelist,
-    };
-    app.use('*', cors(corsOptions));
-
-    // Routes
-    require('./general')(app);
-
-    app.use('/files', require('./codim/router').router);
-
-    app.use('/playground', require('./playground/router').router);
-
-    const cliJsCode = require('./cliJsCode');
-    app.use('/cliJs', cliJsCode.router);
-
-    app.use('/standalone-browser',
-        require('./standalone-browser/registerRoutes').standaloneBrowserRoutes(standaloneBrowserInfo)
-    );
-
-    app.use('/hybrid', require('./hybrid/registerRoutes').hybridRoutes(standaloneBrowserInfo));
-
-    // catch 404
-    app.use((req, res) => {
-        res.status(404).send('Endpoint Not Found');
-    });
-
-    return app;
-};

package/agent/routers/playground/router.js

@@ -1,77 +0,0 @@
-'use strict';
-
-const express = require('express');
-
-const router = express.Router();
-const logger = require('../../../commons/logger').getLogger('playground-router');
-const { ClientError, PlaygroundCodeError } = require('../../../errors');
-const { runPlaygroundTest, stopPlaygroundTest, CODE_TYPES } = require('./service');
-const { DISABLE_AGENT_ORIGIN_CHECK } = require('../../../commons/config');
-
-const VALID_HOSTS = ['localhost', 'app.testim.io', 'playground.testim.io', 'staging.testim.io', 'app.staging.testim.cc', 'tta-crm.tricentis.com'];
-
-const parseUrl = (url) => {
-    if (!url) {
-        return {};
-    }
-    try {
-        return new URL(url);
-    } catch (e) {
-        return {};
-    }
-};
-
-const checkReferer = (req, res, next) => {
-    if (DISABLE_AGENT_ORIGIN_CHECK) {
-        return next();
-    }
-    const referer = req.headers.referer;
-    const origin = req.headers.origin;
-    if (!referer && !origin) {
-        return res.status(400).send();
-    }
-    const refererUrl = parseUrl(referer);
-    const originUrl = parseUrl(origin);
-    if (!VALID_HOSTS.includes(refererUrl.hostname) && !VALID_HOSTS.includes(originUrl.hostname)) {
-        return res.status(400).send();
-    }
-    return next();
-};
-
-router.post('/run', [checkReferer], async (req, res) => {
-    const body = req.body || {};
-    const { code, type } = body;
-
-    if (!code || !CODE_TYPES.includes(type)) {
-        res.status(400).send({ success: false, reason: 'missing arguments' });
-        return;
-    }
-
-    try {
-        await runPlaygroundTest(body);
-        res.send({ success: true });
-    } catch (e) {
-        if (e instanceof ClientError) {
-            res.status(404).send({ success: false });
-            return undefined;
-        }
-        if (e instanceof PlaygroundCodeError) {
-            res.json({ success: false, type: 'playground-error', stack: e.innerStack });
-            return undefined;
-        }
-        res.json({ success: false, reason: e.message });
-        logger.error(e);
-    }
-});
-
-router.post('/stop', (req, res) => {
-    try {
-        stopPlaygroundTest();
-        res.send({ success: true });
-    } catch (e) {
-        res.json({ success: false, reason: e.message });
-        logger.error(e);
-    }
-});
-
-module.exports.router = router;

package/agent/routers/playground/service.js

@@ -1,96 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { fork } = require('child_process');
-const { ClientError, PlaygroundCodeError } = require('../../../errors');
-
-const CODE_TYPES = ['playwright', 'selenium', 'puppeteer'];
-
-const runForks = {};
-
-async function createTempFile(fileName, data, encoding = 'utf8') {
-    const fullPath = path.join(os.tmpdir(), fileName);
-    await fs.promises.writeFile(fullPath, data, encoding);
-    return fullPath;
-}
-
-const forkAsync = (fileFullPath) => {
-    let gotResolved;
-    const promise = new Promise(resolve => { gotResolved = resolve; });
-
-    const child = fork(fileFullPath, { stdio: ['inherit', 'inherit', 'inherit', 'ipc'] });
-    promise.child = child;
-    child.on('message', (message) => {
-        if (!message) {
-            return;
-        }
-        const { type, error } = message;
-        if (error && ['uncaughtException', 'unhandledRejection'].includes(type)) {
-            gotResolved({ error: Object.assign(new PlaygroundCodeError(), { innerStack: message.error.stack }) });
-        }
-    });
-    child.on('error', (error) => {
-        gotResolved({ error });
-    });
-    child.on('exit', (exitCode) => {
-        gotResolved({ exitCode });
-    });
-
-    return promise;
-};
-
-async function runCodeLocally({ code }) {
-    const forkId = Date.now();
-    try {
-        const codeWithExtra = `
-        module.paths = ${JSON.stringify(module.paths)};
-        process.on('unhandledRejection', (error) => {
-            process.send({type: 'unhandledRejection', error: {message: error.message, stack: error.stack}});
-            process.exit(1);
-        });
-        process.on('uncaughtException', (error) => {
-            process.send({type: 'uncaughtException', error: {message: error.message, stack: error.stack}});
-            process.exit(1);
-        });
-        ${code};
-    `;
-        const fileFullPath = await createTempFile(`tst-playground-${Date.now()}.js`, codeWithExtra);
-        const promiseExec = forkAsync(fileFullPath);
-        runForks[forkId] = promiseExec.child;
-        const { error, exitCode } = await promiseExec;
-        if (error) {
-            throw error;
-        }
-        if (exitCode !== 0) {
-            throw new Error(`Process exited with exit code: ${exitCode}`);
-        }
-        return undefined;
-    } finally {
-        if (runForks[forkId]) {
-            runForks[forkId].kill();
-            delete runForks[forkId];
-        }
-    }
-}
-
-async function runPlaygroundTest({ code, type }) {
-    if (['playwright', 'puppeteer', 'selenium'].includes(type)) {
-        return runCodeLocally({ code });
-    }
-    throw new ClientError();
-}
-
-async function stopPlaygroundTest() {
-    Object.keys(runForks).forEach((forkId) => {
-        runForks[forkId].kill();
-        delete runForks[forkId];
-    });
-}
-
-module.exports = {
-    CODE_TYPES,
-    runPlaygroundTest,
-    stopPlaygroundTest,
-};