@testim/testim-cli 3.266.0 → 3.268.0

package/services/gridService.js

@@ -59,38 +59,47 @@ function getSerializableObject(grid) {
     };
 }
 
-function handleGetGridResponse(projectId, companyId, workerId, browser, getFun) {
-    return getFun()
-        .catch(err => {
-            logger.error('failed to get grid', { projectId, companyId, err });
-            throw new Error(gridMessages.UNKNOWN);
-        })
-        .then(async (res) => {
-            logger.info('get grid info', Object.assign({}, res, { projectId, companyId }));
-            const isSuccess = () => res.status === 'success';
-            const isError = () => res.status === 'error' && res.code;
-            if (!res || (!isError() && !isSuccess())) {
-                logger.error('invalid response - get grid', { res });
-                throw new Error(gridMessages.UNKNOWN);
-            }
-
-            if (isSuccess()) {
-                const serGrid = getSerializableObject(res.grid);
-                module.exports.addItemToGridCache(workerId, companyId, serGrid.gridId, serGrid.slotId, browser);
-                return serGrid;
-            }
-
-            if (isError() && res.code === 'not-found') {
-                throw new GridError(gridMessages.NOT_FOUND);
-            }
-
-            if (isError() && res.code === 'no-available-slot') {
-                throw new GridError(`Failed to run test on ${browser} - concurrency limit reached`);
-            }
-
-            logger.error('invalid code error response - get grid', { res });
-            throw new GridError(gridMessages.UNKNOWN);
-        });
+/**
+ * @template {{ status: string; code?: string; grid: * }} T
+ * @param {string} projectId
+ * @param {string} companyId
+ * @param {number} workerId
+ * @param {string} browser
+ * @param {() => Promise<T>} getFun
+ */
+async function handleGetGridResponse(projectId, companyId, workerId, browser, getFun) {
+    /** @type {T} */
+    let res;
+    try {
+        res = await getFun();
+    } catch (err) {
+        logger.error('failed to get grid', { projectId, companyId, err });
+        throw new Error(gridMessages.UNKNOWN);
+    }
+    logger.info('get grid info', Object.assign({}, res, { projectId, companyId }));
+    const isSuccess = () => res.status === 'success';
+    const isError = () => res.status === 'error' && res.code;
+    if (!res || (!isError() && !isSuccess())) {
+        logger.error('invalid response - get grid', { res });
+        throw new Error(gridMessages.UNKNOWN);
+    }
+
+    if (isSuccess()) {
+        const serGrid = getSerializableObject(res.grid);
+        module.exports.addItemToGridCache(workerId, companyId, serGrid.gridId, serGrid.slotId, browser);
+        return serGrid;
+    }
+
+    if (isError() && res.code === 'not-found') {
+        throw new GridError(gridMessages.NOT_FOUND);
+    }
+
+    if (isError() && res.code === 'no-available-slot') {
+        throw new GridError(`Failed to run test on ${browser} - concurrency limit reached`);
+    }
+
+    logger.error('invalid code error response - get grid', { res });
+    throw new GridError(gridMessages.UNKNOWN);
 }
 
 function addItemToGridCache(workerId, companyId, gridId, slotId, browser) {
@@ -264,7 +273,13 @@ async function getGridData(options) {
     throw new GridError('Missing host or grid configuration');
 }
 
-async function getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
+/**
+ * @param {string} browser
+ * @param {string} executionId
+ * @param {import('../runOptions')} options
+ * @param {number} workerId
+ */
+async function getGridSlot(browser, executionId, options, workerId) {
     const getGridDataFromServer = async () => {
         const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher, company = {} } = options;
         const companyId = company.companyId;
@@ -284,9 +299,6 @@ async function getGridSlot(browser, executionId, testResultId, onGridSlot, optio
     };
 
     const gridInfo = await getGridDataFromServer();
-
-    await onGridSlot(executionId, testResultId, gridInfo);
-
     return gridInfo;
 }
 

package/services/gridService.test.js

@@ -169,14 +169,12 @@ describe('gridService', () => {
     describe('getGridSlot', () => {
         let getGridByIdStub;
         let getGridByNameStub;
-        let onGridSlot;
         let addItemToGridCacheStub;
 
         beforeEach(() => {
             getGridByIdStub = sinon.stub(servicesApi, 'getGridById').resolves({ grid: { gridId: 'gridId', type: 'gridId' }, status: 'success' });
             getGridByNameStub = sinon.stub(servicesApi, 'getGridByName').resolves({ grid: { gridId: 'gridId', type: 'gridName' }, status: 'success' });
             addItemToGridCacheStub = sinon.stub(gridService, 'addItemToGridCache').callThrough();
-            onGridSlot = sinon.stub().resolves();
         });
         afterEach(() => {
             getGridByIdStub.restore();
@@ -185,82 +183,77 @@ describe('gridService', () => {
         });
 
         it('should not access server when using useLocalChromeDriver flag', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { useLocalChromeDriver: true }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { useLocalChromeDriver: true }, 'workerId');
             expect(slot).to.eql({ mode: 'local' });
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should not access server when using useChromeLauncher flag', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { useChromeLauncher: true }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { useChromeLauncher: true }, 'workerId');
             expect(slot).to.eql({ mode: 'local' });
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should return fixed grid when passing host and port', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { host: 'localhost', port: 4444 }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { host: 'localhost', port: 4444 }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'hostAndPort', host: 'localhost', port: 4444 });
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should get grid from server when passing grid id', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'gridId', gridId: 'gridId' });
             sinon.assert.calledOnce(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.calledOnce(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should get grid from server when passing grid name', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { grid: 'gridName' }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { grid: 'gridName' }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'gridName', gridId: 'gridId' });
             sinon.assert.calledOnce(getGridByNameStub);
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.calledOnce(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should handle grid not found error', async () => {
             getGridByIdStub.resolves({ status: 'error', code: 'not-found' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('The specified grid is not available');
         });
 
         it('should handle no available slot error', async () => {
             getGridByIdStub.resolves({ status: 'error', code: 'no-available-slot' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Failed to run test on browser - concurrency limit reached');
         });
 
         it('should handle getGridSlot request error', async () => {
             getGridByIdStub.rejects({ status: 'error', code: 'not-found' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
         });
 
         it('should throw when no grid selected', async () => {
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, {}, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', {}, 'workerId'))
                 .to.eventually.be.rejectedWith('Missing host or grid configuration');
         });
 
         it('should handle unkonwn errors', async () => {
             getGridByIdStub.resolves({ status: 'error', code: 'bla bla' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
         });
 
         it('should handle no status', async () => {
             getGridByIdStub.resolves({ code: 'bla bla' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
         });
     });