@testim/testim-cli 3.238.0 → 3.241.0

package/commons/testimCloudflare.js

@@ -40,14 +40,21 @@ async function prepareTunnel() {
 }
 
 const connectTunnel = async (options) => {
+    const tunnelBaseUrl = options.baseUrl || `http://localhost:${options.tunnelPort || 80}`;
+    const tunnelRoutes = options.tunnelRoutes || [tunnelBaseUrl];
     const [result] = await Promise.all([
-        servicesApi.getCloudflareTunnel(options.company.companyId, options.tunnelRoutes),
+        servicesApi.getCloudflareTunnel(options.company.companyId, tunnelRoutes),
         module.exports.prepareTunnel(),
     ]);
     tunnelId = result._id;
     tunnelProcess = childProcess.spawn(TUNNEL_BINARY_LOCATION, ['tunnel', '--no-autoupdate', 'run', '--force', '--token', result.token], { stdio: 'inherit' });
     await servicesApi.forceUpdateCloudflareTunnelRoutes(options.company.companyId, tunnelId);
-    await fse.writeFileSync(options.tunnelRoutesOutput, JSON.stringify(result.routesMapping, null, 2));
+
+    if (options.tunnelRoutesOutput) {
+        await fse.writeFileSync(options.tunnelRoutesOutput, JSON.stringify(result.routesMapping, null, 2));
+    }
+
+    options.baseUrl = `${options.tunnelUseHttpAddress ? 'http' : 'https'}://${result.routesMapping[tunnelBaseUrl]}`;
 };
 
 const disconnectTunnel = async (options) => {

package/commons/testimCloudflare.test.js

@@ -43,7 +43,7 @@ describe('testimCloudflare', () => {
             killStub = sandbox.stub(processMock, 'kill').callThrough();
             sandbox.stub(childProcess, 'spawn').returns(processMock);
             sandbox.stub(testimCloudflare, 'prepareTunnel');
-            sandbox.stub(servicesApi, 'getCloudflareTunnel').resolves({ _id: utils.guid() });
+            sandbox.stub(servicesApi, 'getCloudflareTunnel').resolves({ _id: utils.guid(), routesMapping: {} });
             sandbox.stub(servicesApi, 'forceUpdateCloudflareTunnelRoutes');
             sandbox.stub(fse, 'writeFileSync');
         });
@@ -127,7 +127,7 @@ describe('testimCloudflare', () => {
         let tunnelData;
 
         beforeEach(() => {
-            tunnelData = { _id: utils.guid(), token: utils.guid() };
+            tunnelData = { _id: utils.guid(), token: utils.guid(), routesMapping: {} };
             prepareTunnelStub = sandbox.stub(testimCloudflare, 'prepareTunnel');
             getCloudflareTunnelStub = sandbox.stub(servicesApi, 'getCloudflareTunnel').resolves(tunnelData);
             forceUpdateCloudflareTunnelRoutesStub = sandbox.stub(servicesApi, 'forceUpdateCloudflareTunnelRoutes');
@@ -154,9 +154,32 @@ describe('testimCloudflare', () => {
 
         it('should write the tunnel data to a file', async () => {
             tunnelData.routesMapping = utils.guid();
-            await testimCloudflare.connectTunnel({ company: {} });
+            await testimCloudflare.connectTunnel({ company: {}, tunnelRoutesOutput: 'test.json' });
             sinon.assert.calledOnce(writeFileSyncStub);
+            expect(writeFileSyncStub.args[0][0]).to.eql('test.json');
             expect(writeFileSyncStub.args[0][1]).to.eql(JSON.stringify(tunnelData.routesMapping));
         });
+
+        it('should set the baseUrl to the tunneled url', async () => {
+            tunnelData.routesMapping = { 'http://localhost:80': utils.guid() };
+            const opts = { company: {} };
+            await testimCloudflare.connectTunnel(opts);
+            expect(opts.baseUrl).to.eql(`https://${tunnelData.routesMapping['http://localhost:80']}`);
+        });
+
+        it('should set the baseUrl to the tunneled url, overriding an existing baseURL', async () => {
+            const baseUrl = utils.guid();
+            tunnelData.routesMapping = { [baseUrl]: utils.guid() };
+            const opts = { company: {}, baseUrl };
+            await testimCloudflare.connectTunnel(opts);
+            expect(opts.baseUrl).to.eql(`https://${tunnelData.routesMapping[baseUrl]}`);
+        });
+
+        it('should set the baseUrl considering tunnelUseHttpAddress', async () => {
+            tunnelData.routesMapping = { 'http://localhost:80': utils.guid() };
+            const opts = { company: {}, tunnelUseHttpAddress: true };
+            await testimCloudflare.connectTunnel(opts);
+            expect(opts.baseUrl).to.eql(`http://${tunnelData.routesMapping['http://localhost:80']}`);
+        });
     });
 });

package/commons/testimDesiredCapabilitiesBuilder.js

@@ -185,6 +185,7 @@ function _buildChromiumOptions(opts, browserOptions, testRunConfig, customExtens
             'profile.content_settings.exceptions.clipboard': {
                 '[*.],*': { last_modified: Date.now(), setting: 1 },
             },
+            'download.allow_office_viewer_for_download': false,
         },
         w3c: isW3CMode(),
     };

package/commons/testimServicesApi.js

@@ -20,7 +20,7 @@ function getTokenHeader() {
     return testimCustomToken.getCustomTokenV3()
         .then(brearToken => {
             if (!brearToken) {
-                return Promise.reject(new Error('Failed to get token from server'));
+                throw new Error('Failed to get token from server');
             }
             return { Authorization: `Bearer ${brearToken}` };
         });
@@ -386,6 +386,19 @@ function uploadArtifact(projectId, testId, testResultId, content, subType, mimeT
     })).then(() => storagePath);
 }
 
+const removeHiddenParamsInTestData = (testData, projectDefaults) => {
+    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;
+};
+
 const uploadRunDataArtifact = _.memoize(async (projectId, testId, testResultId, runData) => {
     if (_.isEmpty(runData)) {
         return undefined;
@@ -397,20 +410,8 @@ const updateTestDataArtifact = _.memoize(async (projectId, testId, testResultId,
     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');
+    return await uploadArtifact(projectId, testId, testResultId, JSON.stringify(removeHiddenParamsInTestData(testData, projectDefaults)), 'test-test-data', 'application/json');
 }, (projectId, testId, testResultId, testData) => `${hash(testData)}:${testId}:${testResultId}`);
 
 function addTestRetry({
@@ -510,4 +511,5 @@ module.exports = {
     getCloudflareTunnel,
     forceUpdateCloudflareTunnelRoutes,
     deleteCloudflareTunnel,
+    removeHiddenParamsInTestData,
 };

package/commons/testimTunnel.js

@@ -10,7 +10,8 @@ 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 !== 'ngrok';
+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) {
@@ -23,7 +24,7 @@ const connect = async (options) => {
         if (shouldUseLambdatestTunnel(options)) {
             spinner = ora('Starting testim lambdatest tunnel...').start();
             await LambdatestService.connectTunnel(options);
-        } else if (options.tunnelRoutes) {
+        } else if (shouldUseCloudflareTunnel(options)) {
             spinner = ora('Starting testim cloudflare tunnel...').start();
             await testimCloudflare.connectTunnel(options);
         } else {

package/commons/testimTunnel.test.js

@@ -44,14 +44,14 @@ describe('testimTunnel', () => {
         });
 
         it('should choose lambdatest if passed grid is a lambdatest grid', async () => {
-            await testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest' } });
+            await testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } });
             sinon.assert.calledOnce(ltConnectStub);
             sinon.assert.notCalled(ngrokConnectStub);
             sinon.assert.notCalled(cloudflareConnectStub);
         });
 
         it('should choose lambdatest if passed grid is a hybrid grid', async () => {
-            await testimTunnel.connect({ tunnel: true, gridData: { type: 'testimHybrid' } });
+            await testimTunnel.connect({ tunnel: true, gridData: { type: 'testimHybrid', tunnel: 'lambdatest' } });
             sinon.assert.calledOnce(ltConnectStub);
             sinon.assert.notCalled(ngrokConnectStub);
             sinon.assert.notCalled(cloudflareConnectStub);
@@ -66,7 +66,7 @@ describe('testimTunnel', () => {
 
         it('should handle connect errors', async () => {
             ltConnectStub.rejects('error');
-            await expect(testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest' } })).to.be.rejectedWith('Failed to start tunnel. Please contact support@testim.io');
+            await expect(testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } })).to.be.rejectedWith('Failed to start tunnel. Please contact support@testim.io');
         });
     });
 
@@ -108,14 +108,14 @@ describe('testimTunnel', () => {
         });
 
         it('should choose lambdatest if passed grid is a lambdatest grid', async () => {
-            await testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimLambdaTest' } });
+            await testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } });
             sinon.assert.calledOnce(ltDisconnectStub);
             sinon.assert.notCalled(ngrokDisconnectStub);
             sinon.assert.notCalled(cloudflareDisconnectStub);
         });
 
         it('should choose lambdatest if passed grid is a hybrid grid', async () => {
-            await testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimHybrid' } });
+            await testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimHybrid', tunnel: 'lambdatest' } });
             sinon.assert.calledOnce(ltDisconnectStub);
             sinon.assert.notCalled(ngrokDisconnectStub);
             sinon.assert.notCalled(cloudflareDisconnectStub);
@@ -130,7 +130,7 @@ describe('testimTunnel', () => {
 
         it('should handle connect errors', async () => {
             ltDisconnectStub.rejects('error');
-            await expect(testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimLambdaTest' } })).to.be.rejectedWith('catch error - failed to close tunnel');
+            await expect(testimTunnel.disconnect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } })).to.be.rejectedWith('catch error - failed to close tunnel');
         });
     });