@testim/testim-cli 3.289.0 → 3.290.0

package/services/lambdatestService.test.js

@@ -1,353 +0,0 @@
-const { expect, sinon } = require('../../test/utils/testUtils');
-const servicesApi = require('../commons/testimServicesApi');
-const httpRequest = require('../commons/httpRequest');
-const LambdatestService = require('./lambdatestService');
-const utils = require('../utils');
-const fse = require('fs-extra');
-const { AbortError } = require('p-retry');
-const os = require('os');
-const childProcess = require('child_process');
-const EventEmitter = require('events');
-const portfinder = require('portfinder');
-const { getExtensionsUrl } = require('../runOptionsUtils');
-
-class Process extends EventEmitter {
-    constructor() {
-        super();
-        this.stdout = new EventEmitter();
-        this.stderr = new EventEmitter();
-    }
-    setCode(code) {
-        this.code = code;
-    }
-    kill() {
-        this.emit('close', this.code);
-    }
-}
-
-describe('LambdatestService', () => {
-    let sandbox;
-    let lambdatestService;
-    beforeEach(() => {
-        lambdatestService = new LambdatestService();
-        sandbox = sinon.createSandbox();
-    });
-    afterEach(() => {
-        sandbox.restore();
-    });
-
-    describe('isLambdatestGrid', () => {
-        it('should consider a lambda test grid as a lambda test grid', () => {
-            expect(LambdatestService.isLambdatestGrid({ type: 'testimLambdaTest' })).to.be.true;
-        });
-        it('should consider a hybrid grid as a lambda test grid according to ist provider', () => {
-            expect(LambdatestService.isLambdatestGrid({ type: 'testimHybrid', provider: 'lambdatest' })).to.be.true;
-            expect(LambdatestService.isLambdatestGrid({ type: 'testimHybrid', provider: 'other' })).to.be.false;
-        });
-    });
-
-    describe('isLambdatestRun', () => {
-        it('should consider a lambda test run as a lambda test run', () => {
-            lambdatestService.isActive = true;
-            expect(lambdatestService.isLambdatestRun()).to.be.true;
-        });
-
-        it('should consider non lambda test run as non lambda test run', () => {
-            lambdatestService.isActive = false;
-            expect(lambdatestService.isLambdatestRun()).to.be.false;
-        });
-    });
-
-    describe('enableIfNeeded', () => {
-        let fetchLambdatestConfigStub;
-        beforeEach(() => {
-            fetchLambdatestConfigStub = sinon.stub(servicesApi, 'fetchLambdatestConfig').resolves({});
-        });
-        afterEach(() => {
-            fetchLambdatestConfigStub.restore();
-            delete LambdatestService.lambdatestConfigPromise;
-            delete LambdatestService.lambdatestConfig;
-        });
-
-        it('should not enable lambdatest for non lt grid', async () => {
-            await lambdatestService.enableIfNeeded({});
-            expect(lambdatestService.isActive).to.be.false;
-            sinon.assert.notCalled(fetchLambdatestConfigStub);
-        });
-
-        it('should enable lambdatest for lt grid', async () => {
-            await lambdatestService.enableIfNeeded({ type: 'testimLambdaTest' });
-            expect(lambdatestService.isActive).to.be.true;
-            sinon.assert.calledOnce(fetchLambdatestConfigStub);
-        });
-
-        it('should enable lambdatest for hybrid grid with lt provider', async () => {
-            await lambdatestService.enableIfNeeded({ type: 'testimHybrid', provider: 'lambdatest' });
-            expect(lambdatestService.isActive).to.be.true;
-            sinon.assert.calledOnce(fetchLambdatestConfigStub);
-        });
-
-        it('should not enable lambdatest for hybrid grid with other provider', async () => {
-            await lambdatestService.enableIfNeeded({ type: 'testimHybrid', provider: 'other' });
-            expect(lambdatestService.isActive).to.be.false;
-            sinon.assert.notCalled(fetchLambdatestConfigStub);
-        });
-
-        it('should cache lambdatest config', async () => {
-            await lambdatestService.enableIfNeeded({ type: 'testimLambdaTest' });
-            await lambdatestService.enableIfNeeded({ type: 'testimLambdaTest' });
-            sinon.assert.calledOnce(fetchLambdatestConfigStub);
-        });
-    });
-
-    describe('specific lt capabilities', () => {
-        it('should return lt session timeout for lt grid', async () => {
-            lambdatestService.isActive = true;
-            expect(lambdatestService.getSessionTimeout).to.be.equal(900000);
-            lambdatestService.isActive = false;
-            expect(lambdatestService.getSessionTimeout).to.be.equal(null);
-        });
-
-        it('should return lt session retries for lt grid', async () => {
-            lambdatestService.isActive = true;
-            expect(lambdatestService.getSessionRetries).to.be.equal(1);
-            lambdatestService.isActive = false;
-            expect(lambdatestService.getSessionRetries).to.be.equal(null);
-        });
-
-        it('should not return lt special selenium capabilities when inactove', () => {
-            lambdatestService.isActive = false;
-            expect(lambdatestService.getCapabilities({})).to.eql({});
-        });
-
-        it('should return lt selenium capabilities', () => {
-            const browser = utils.guid();
-            const executionId = utils.guid();
-            const testResultId = utils.guid();
-            const testName = utils.guid();
-
-            lambdatestService.isActive = true;
-            LambdatestService.lambdatestConfig = {
-                CAPABILITIES: { [browser]: { specificBrowserCaps: 123 } },
-            };
-
-            expect(lambdatestService.getCapabilities({}, browser, executionId, testResultId, testName)).to.shallowDeepEqual({
-                build: executionId,
-                name: `${testResultId} - ${testName}`,
-                platform: LambdatestService.lambdatestConfig.PLATFORM,
-                // eslint-disable-next-line camelcase
-                selenium_version: LambdatestService.lambdatestConfig.SELENIUM_VERSION,
-                resolution: LambdatestService.lambdatestConfig.RESOLUTION,
-                timezone: LambdatestService.lambdatestConfig.TIMEZONE,
-                specificBrowserCaps: 123,
-                console: true,
-                queueTimeout: 300,
-            });
-        });
-
-        it('should return lt tunnel name as part of selenium capabilities', () => {
-            lambdatestService.isActive = true;
-            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
-            LambdatestService.tunnelName = utils.guid();
-
-            expect(lambdatestService.getCapabilities({})).to.shallowDeepEqual({
-                tunnel: true,
-                tunnelName: LambdatestService.tunnelName,
-            });
-        });
-
-        it('should load testim extension when it is not set', () => {
-            lambdatestService.isActive = true;
-            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
-            LambdatestService.tunnelName = utils.guid();
-
-            expect(lambdatestService.getCapabilities({ mode: 'extension' }, 'chrome')).to.shallowDeepEqual({ loadExtension: [getExtensionsUrl({}, true).chrome] });
-            expect(lambdatestService.getCapabilities({ mode: 'extension' }, 'somOtherBrowser')).to.shallowDeepEqual({ loadExtension: [] });
-        });
-
-        it('should load testim extension when passing extensionPath flag', () => {
-            lambdatestService.isActive = true;
-            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
-            LambdatestService.tunnelName = utils.guid();
-
-            const extensionPath = 'http://localhost:1234/extension.zip';
-            expect(lambdatestService.getCapabilities({ mode: 'extension', extensionPath })).to.shallowDeepEqual({ loadExtension: [extensionPath] });
-        });
-
-        it('should load testim extension when passing installCustomExtension flag', () => {
-            lambdatestService.isActive = true;
-            LambdatestService.lambdatestConfig = { CAPABILITIES: {} };
-            LambdatestService.tunnelName = utils.guid();
-
-            const installCustomExtension = 'http://localhost:1234/extension.zip';
-            expect(lambdatestService.getCapabilities({ mode: 'extension', installCustomExtension })).to.shallowDeepEqual({ loadExtension: [installCustomExtension] });
-        });
-    });
-
-    describe('prepareTunnel', () => {
-        it('should do nothing when tunnel binary already exists', async () => {
-            sandbox.stub(fse, 'pathExists').resolves(true);
-            const chmod = sandbox.stub(fse, 'chmodSync');
-            await LambdatestService.prepareTunnel();
-            expect(chmod).not.to.have.been.called;
-        });
-
-        it('should throw when unsupported os', async () => {
-            sandbox.stub(fse, 'pathExists').resolves(false);
-            sandbox.stub(os, 'platform').returns('wtf');
-            sandbox.stub(os, 'arch').returns('wtf');
-
-            await expect(LambdatestService.prepareTunnel()).to.be.rejectedWith(Error, 'tunnel on wtfwtf platform is not supported.');
-        });
-
-        it('should download and extract tunnel binary', async () => {
-            sandbox.stub(fse, 'pathExists').resolves(false);
-            sandbox.stub(os, 'platform').returns('win32');
-            sandbox.stub(os, 'arch').returns('x64');
-
-            const download = sandbox.stub(utils, 'downloadAndSave');
-            const unzip = sandbox.stub(utils, 'unzipFile').resolves();
-
-            await LambdatestService.prepareTunnel();
-            sinon.assert.calledOnce(unzip);
-            sinon.assert.calledOnce(download);
-            expect(download.args[0][0]).to.startWith('https://downloads.lambdatest.com/tunnel/');
-        });
-    });
-
-    describe('connectTunnel', () => {
-        let prepareTunnelStub;
-        let spawnStub;
-        let credentials;
-        let httpGetStub;
-        let processMock;
-
-        beforeEach(() => {
-            processMock = new Process();
-            credentials = { gridUsername: utils.guid(), gridPassword: utils.guid() };
-            sandbox.stub(portfinder, 'getPortPromise').resolves(1234);
-            prepareTunnelStub = sandbox.stub(LambdatestService, 'prepareTunnel');
-            spawnStub = sandbox.stub(childProcess, 'spawn').returns(processMock);
-            httpGetStub = sandbox.stub(httpRequest, 'get').resolves({});
-        });
-
-        it('should do nothing when using externalLambdatestTunnelId', async () => {
-            await LambdatestService.connectTunnel({ externalLambdatestTunnelId: 123 });
-            sinon.assert.neverCalledWith(prepareTunnelStub);
-            sinon.assert.neverCalledWith(spawnStub);
-        });
-
-        it('should prepare the tunnel', async () => {
-            await LambdatestService.connectTunnel({ ...credentials });
-            sinon.assert.calledOnce(prepareTunnelStub);
-        });
-
-        it('should reject when no credentials', async () => {
-            await expect(LambdatestService.connectTunnel({ })).to.be.rejectedWith(Error, 'tunnel requires username and password');
-        });
-
-        it('should spawn the tunnel process', async () => {
-            await LambdatestService.connectTunnel({ ...credentials });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1]).to.eql([
-                '--tunnelName', LambdatestService.tunnelName, '--infoAPIPort', 1234,
-                '--user', credentials.gridUsername, '--key', credentials.gridPassword,
-            ]);
-        });
-
-        it('should accept tunnelUser and tunnelKey on gridData', async () => {
-            credentials = { gridData: { tunnelUser: utils.guid(), tunnelKey: utils.guid() } };
-            await LambdatestService.connectTunnel({ ...credentials });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1]).to.eql([
-                '--tunnelName', LambdatestService.tunnelName, '--infoAPIPort', 1234,
-                '--user', credentials.gridData.tunnelUser, '--key', credentials.gridData.tunnelKey,
-            ]);
-        });
-
-        it('should allow using externalLambdatestUseWss', async () => {
-            await LambdatestService.connectTunnel({ ...credentials, externalLambdatestUseWss: true });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--mode ws');
-        });
-
-        it('should allow using proxyUri', async () => {
-            global.proxyUri = 'http://localhost';
-            await LambdatestService.connectTunnel({ ...credentials });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-host localhost');
-            global.proxyUri = undefined;
-        });
-
-        it('should allow using proxyUri port and credentials', async () => {
-            global.proxyUri = 'http://user:pass@localhost:1234';
-            await LambdatestService.connectTunnel({ ...credentials });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-host localhost');
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-port 1234');
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-user user');
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--proxy-pass pass');
-            global.proxyUri = undefined;
-        });
-
-        it('should throw when proxyUri is invalid', async () => {
-            global.proxyUri = 'i am invalid';
-            await expect(LambdatestService.connectTunnel({ ...credentials })).to.be.rejectedWith(Error, 'proxy url is invalid');
-            global.proxyUri = undefined;
-        });
-
-        it('should allow using externalLambdatestDisableAutomationTunneling', async () => {
-            await LambdatestService.connectTunnel({ ...credentials, externalLambdatestDisableAutomationTunneling: true });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--bypassHosts run.testim.io,services.testim.io,api.coralogix.com,conf.rollout.io,statestore.rollout.io,push.rollout.io,analytic.rollout.io,res.cloudinary.com');
-        });
-
-        it('should allow using externalLambdatestMitm', async () => {
-            await LambdatestService.connectTunnel({ ...credentials, externalLambdatestMitm: true });
-            sinon.assert.calledOnce(spawnStub);
-            expect(spawnStub.args[0][1].join(' ')).to.contain('--mitm');
-        });
-
-        it('should verify tunnel started', async () => {
-            await LambdatestService.connectTunnel({ ...credentials });
-            sinon.assert.calledOnce(httpGetStub);
-        });
-        it('should throw when tunnel did not start', async () => {
-            httpGetStub.rejects(new AbortError('tunnel did not start'));
-            await expect(LambdatestService.connectTunnel({ ...credentials })).to.be.rejectedWith(Error, 'tunnel did not start');
-            processMock.stdout.emit('data', '');
-            processMock.stderr.emit('data', '');
-        });
-    });
-
-    describe('disconnectTunnel', () => {
-        let processMock;
-        let killStub;
-
-        beforeEach(() => {
-            processMock = new Process();
-            killStub = sandbox.stub(processMock, 'kill').callThrough();
-            sandbox.stub(childProcess, 'spawn').returns(processMock);
-            sandbox.stub(LambdatestService, 'prepareTunnel');
-            sandbox.stub(httpRequest, 'get').resolves({});
-        });
-
-        it('should kill the tunnel', async () => {
-            await LambdatestService.connectTunnel({ tunnel: true, company: {}, gridUsername: utils.guid(), gridPassword: utils.guid() });
-            await LambdatestService.disconnectTunnel({ company: {} });
-            sinon.assert.calledOnce(killStub);
-        });
-
-        it('should reject when killing the tunnel fails', async () => {
-            processMock.setCode(1);
-            await LambdatestService.connectTunnel({ tunnel: true, company: {}, gridUsername: utils.guid(), gridPassword: utils.guid() });
-            await expect(LambdatestService.disconnectTunnel({ company: {} })).to.be.rejectedWith(Error);
-            sinon.assert.calledOnce(killStub);
-        });
-
-        it('should do nothing when using externalLambdatestTunnelId', async () => {
-            await LambdatestService.disconnectTunnel({ externalLambdatestTunnelId: 123 });
-            sinon.assert.neverCalledWith(killStub);
-        });
-    });
-});

package/services/localRCASaver.js

@@ -1,124 +0,0 @@
-const { ArgError } = require('../errors');
-const express = require('express');
-const fs = require('fs-extra');
-const os = require('os');
-const path = require('path');
-const lazyRequire = require('../commons/lazyRequire');
-
-const DEFUALT_PATH = path.join(os.tmpdir(), 'testim/rca/');
-
-const stepFileMap = {};
-const resultFileMap = {};
-
-const TYPE_RENAMES = {
-    'test-log': 'consoleLogs',
-    'har-file': 'networkLogs',
-};
-const TYPES = Object.keys(TYPE_RENAMES);
-
-function mapFilesToLocalDrive(test, logger) {
-    try {
-        test.failurePath = (test.failurePath || []).map(f => Object.assign(f, stepFileMap[f.id] ? { screenshot: stepFileMap[f.id] } : {}));
-        Object.keys(resultFileMap).forEach(type => {
-            test.assets = test.assets || {};
-            test.assets[TYPE_RENAMES[type]] = resultFileMap[type];
-        });
-
-        test.assets = test.assets || {};
-        test.assets.screenshots = Object.values(stepFileMap);
-    } catch (err) {
-        if (logger) {
-            logger.error('failed to map files to local drive', { err });
-        }
-        // set default values.
-        test.failurePath = test.failurePath || [];
-        test.assets = test.assets || {};
-        test.assets.screenshots = test.assets.screenshots || [];
-    }
-}
-
-/**
- * @param {Partial<Pick<import('../runOptions').AgentModeOptions, 'agentPort' | 'agentBind'> & Pick<import('../runOptions').RunnerOptions, 'saveRCALocally'>>} param0
- * @returns {Promise<import('net').AddressInfo>}
- */
-async function initServer({ agentPort, agentBind, saveRCALocally }) {
-    const multer = await lazyRequire('multer');
-    saveRCALocally = typeof saveRCALocally === 'string' ? saveRCALocally : DEFUALT_PATH;
-
-    await fs.mkdirp(saveRCALocally);
-
-    const upload = multer({
-        storage: multer.diskStorage({
-            async destination(req, file, cb) {
-                const metadata = JSON.parse(req.body.metadata || '{}');
-                if (!metadata.testResultId) {
-                    return cb(new Error('missing testResultId'));
-                }
-                const destination = path.join(saveRCALocally, metadata.testResultId);
-                try {
-                    await fs.mkdirp(destination);
-                } catch (err) {
-                    return cb(err);
-                }
-                return cb(null, destination);
-            },
-            filename(req, file, cb) {
-                const { fileName } = req.body;
-                const metadata = JSON.parse(req.body.metadata || '{}');
-                if (!metadata.stepId && !fileName) {
-                    return cb(new Error('missing stepId or fileName'));
-                }
-                if (metadata.stepId) {
-                    const format = path.extname(fileName);
-                    return cb(null, `step_${metadata.stepId}_${metadata.stepName || ''}${format}`.replace(/[/\\?%*:|"<>\s]/g, '-'));
-                }
-                return cb(null, fileName);
-            },
-        }),
-    });
-
-    const app = express();
-
-    app.post('/', upload.single('file'), (req, res) => {
-        const metadata = JSON.parse(req.body.metadata || '{}');
-        if (metadata.stepId) {
-            stepFileMap[metadata.stepId] = req.file.path;
-        }
-        if (metadata.testResultId && TYPES.includes(metadata.subType)) {
-            resultFileMap[metadata.subType] = resultFileMap[metadata.subType] || [];
-            resultFileMap[metadata.subType].push(req.file.path);
-        }
-        res.sendStatus(200);
-    });
-    app.use((req, res) => res.status(404).send('Endpoint Not Found'));
-
-    return await new Promise((resolve, reject) => {
-        const http = require('http');
-        const server = http.createServer(app);
-        server.listen(agentPort, agentBind);
-        server.on('error', onError);
-        server.on('listening', () => resolve(server.address()));
-
-        function onError(error) {
-            if (error.syscall !== 'listen') {
-                return reject(error);
-            }
-
-            // handle specific listen errors with friendly messages
-            switch (error.code) {
-                case 'EACCES':
-                case 'EPERM':
-                    return reject(new ArgError(`Port ${agentPort} requires elevated privileges`));
-                case 'EADDRINUSE':
-                    return reject(new ArgError(`Port ${agentPort} is already in use`));
-                default:
-                    return reject(error);
-            }
-        }
-    });
-}
-
-module.exports = {
-    initServer,
-    mapFilesToLocalDrive,
-};

package/stepPlayers/cliJsStepPlayback.js

@@ -1,40 +0,0 @@
-'use strict';
-
-const service = require('../agent/routers/cliJsCode/service');
-const { TimeoutError } = require('../errors');
-const featureFlags = require('../commons/featureFlags');
-
-function isExceedingMaxResultSize(data, project) {
-    try {
-        const shouldEnforceMaxSize = project.defaults.enforceMaximumJsResultSize;
-        const maximumJsResultSize = featureFlags.flags.maximumJsResultSize.getValue();
-        const dataSizeExceeded = JSON.stringify(data).length > maximumJsResultSize;
-        if (!shouldEnforceMaxSize) {
-            return false;
-        }
-        return dataSizeExceeded;
-    } catch (e) {
-        return false;
-    }
-}
-
-module.exports.run = async (browser, step, projectData) => {
-    const {
-        code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, runTimeout, fileDataUrl, s3filepath,
-    } = step.data;
-    try {
-        const data = await service.runCodeWithPackages(code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, runTimeout, fileDataUrl, s3filepath);
-        if (data && isExceedingMaxResultSize({ result: data.result, tstConsoleLogs: data.tstConsoleLogs }, projectData)) {
-            return {
-                code: 'js-result-max-size-exceeded',
-                success: false,
-            };
-        }
-        return { data, success: true };
-    } catch (err) {
-        if (err instanceof TimeoutError) {
-            throw new Error('Timeout while running action');
-        }
-        throw err;
-    }
-};

package/stepPlayers/hybridStepPlayback.js

@@ -1,140 +0,0 @@
-'use strict';
-
-const MemoryFS = require('memory-fs');
-const AbortController = require('abort-controller');
-const perfLogger = require('../commons/performance-logger');
-const { getLogger } = require('../commons/logger');
-const { sessionType } = require('../commons/constants');
-
-const mfs = new MemoryFS();
-const logger = getLogger('hybrid-step-playback');
-
-/**
- * @type {Map<string, import("abort-controller")>}
- */
-const runningStepsAbortControllersRegistry = new Map();
-
-// TODO(Benji) cache compile between runs with webpack cache plugin or runnerFileCache
-/** @type {import('clickim/src/background/session/code-session-player').CodeSessionPlayer['proxy'] | undefined} */
-let stepsProxy;
-
-module.exports.run = (driver, remoteStep, projectData, userData) => {
-    const { step, context } = remoteStep.data;
-    return module.exports.execute(step, context, driver, userData.loginData);
-    // (step, context, driver, loginData, frameManager)
-};
-
-// this function is exported as a "make sense API", `run` above is teh remote run signature for polymorphic dispatch
-module.exports.execute = async function execute(step, context, driver, loginData, frameManager, source = 'cli') {
-    const abortController = new AbortController();
-    const { signal: abortSignal } = abortController;
-
-    runningStepsAbortControllersRegistry.set(context.stepResultId, abortController);
-
-    try {
-        perfLogger.log('before seleniumTestPlayer require');
-        const SeleniumTestPlayer = require('../player/seleniumTestPlayer');
-        const { compileFunctionsLibrary } = require('../agent/routers/codim/service');
-
-        const { functionName } = step;
-        const userParamsData = {}; // no tdk access
-        //TODO (benji) read function parameters and arguments from context.incomingParams.as
-        const shouldMonitorPerformance = false;
-        const player = new SeleniumTestPlayer(
-            context.id, // has to be on the same session ID to reuse the same tabs from tabService
-            userParamsData,
-            shouldMonitorPerformance,
-            sessionType.CODEFUL,
-            driver,
-        );
-
-        stepsProxy = player.sessionPlayer.codeSessionPlayer.proxy;
-        // reuse the same memory filesystem between runs for cache
-
-        const bypassWebpack = step.bypassWebpack ? { testim: stepsProxy.wrappedSteps() } : false;
-
-        perfLogger.log('before compileFunctionsLibrary', { bypassWebpack: Boolean(step.bypassWebpack) });
-        let code;
-        try {
-            code = await compileFunctionsLibrary({ fileSystem: mfs, bypassWebpack }, abortSignal);
-        } catch (e) {
-            return { success: false, shouldRetry: false, reason: `Unable to compile functions library. ${e.message}`, extraInfo: e.stack };
-        }
-
-        if (typeof globalThis === 'undefined') { // fix for Node 8 and Node 10
-            global.globalThis = process;
-        }
-        let hybridFunction;
-        if (!bypassWebpack) {
-            global.globalThis.__testim = stepsProxy.wrappedSteps();
-            // this evaluates the code while exposing __testim. We manually expose the proxy here since
-            // our test-extractor code assumes it's extracting tests and this just needs to "eval" the whole file
-            (0, eval)(code); // eslint-disable-line no-eval
-            hybridFunction = globalThis.tdk[functionName];
-        } else {
-            hybridFunction = code[functionName];
-        }
-
-        perfLogger.log('after hybridFunction obtain and eval');
-        if (!hybridFunction) {
-            return {
-                success: false,
-                shouldRetry: false,
-                reason: `Could not find function '${functionName}' locally. Please make sure you have a functions.js file with a '${functionName}' function defined`,
-                extraInfo: Object.keys(globalThis.tdk), // log available functions to make debugging easier
-            };
-        }
-
-        if (hybridFunction.type === 'selenium') {
-            const seleniumPlayback = require('./seleniumHybridStepPlayback').execute;
-            return await seleniumPlayback(player, hybridFunction, step, context, source, abortSignal);
-        }
-        if (hybridFunction.type === 'puppeteer') {
-            if (!player.driver.cdpUrl) {
-                return { success: false, shouldRetry: false, reason: 'running puppeteer code requires the remote debugging protocol to be open. Please contact Testim support.' };
-            }
-            perfLogger.log('before puppeteerPlayback');
-            const puppeteerPlayback = require('./puppeteerHybridStepPlayback').execute;
-            try {
-                return await puppeteerPlayback(player, hybridFunction, step, context, source, abortSignal);
-            } finally {
-                perfLogger.log('after puppeteerPlayback');
-            }
-        }
-
-        if (hybridFunction.type === 'playwright') {
-            if (!player.driver.cdpUrl) {
-                return { success: false, shouldRetry: false, reason: 'running playwright code requires the remote debugging protocol to be open. Please contact Testim support.' };
-            }
-            const playwrightPlayback = require('./playwrightHybridStepPlayback').execute;
-            return await playwrightPlayback(player, hybridFunction, step, context, source, abortSignal);
-        }
-
-        if (hybridFunction.type === 'tdk' || !hybridFunction.type) {
-            const tdkPlayback = require('./tdkHybridStepPlayback').execute;
-            perfLogger.log('before tdkPlayback');
-            try {
-                return await tdkPlayback(player, hybridFunction, context, loginData, frameManager, step, source, abortSignal);
-            } finally {
-                perfLogger.log('after tdkPlayback');
-            }
-        }
-
-        return { success: false, shouldRetry: false, reason: `unknown hybrid format ${hybridFunction.type}` };
-    } catch (err) {
-        logger.info('error running hybrid step', { err });
-        return undefined;
-    } finally {
-        runningStepsAbortControllersRegistry.delete(context.stepResultId);
-    }
-};
-
-module.exports.abort = function abort(stepResultId) {
-    const abortController = runningStepsAbortControllersRegistry.get(stepResultId);
-
-    if (abortController) {
-        abortController.abort();
-    } else {
-        throw new Error('No such stepResultId');
-    }
-};