@testim/testim-cli 3.254.0 → 3.256.0

package/player/utils/imageCaptureUtils.js

@@ -1,7 +1,10 @@
+// @ts-check
+
 'use strict';
 
-const Promise = require('bluebird');
+const _ = require('lodash');
 const Jimp = require('jimp');
+const utils = require('../../utils');
 
 const logger = require('../../commons/logger').getLogger('image-capture-utils');
 
@@ -13,22 +16,17 @@ class RectIsOutsideOfImageError extends Error {
     }
 }
 
-const ImageCaptureUtils = function (tabId, windowUtils, screenshotUtils) {
-    this.windowUtils = windowUtils;
-    this.screenshotUtils = screenshotUtils;
-};
-
-function cropImageFromImageData(imageData, imageInfo) {
-    const image = imageInfo.image || imageInfo;
+async function cropImageFromImageData(imageData, imageInfo) {
+    const _image = imageInfo.image || imageInfo;
     const pixelRatio = imageInfo.devicePixelRatio;
 
-    if (!image) {
-        return Promise.reject(new Error('Failed to get image'));
+    if (!_image) {
+        throw new Error('Failed to get image');
     }
 
-    const imageRegExMatch = image.match(/^data\:[^;]*\;base64,(.*)$/);
+    const imageRegExMatch = _image.match(/^data\:[^;]*\;base64,(.*)$/);
     if (!imageRegExMatch) {
-        return Promise.reject(new Error('Image is not in base64 format'));
+        throw new Error('Image is not in base64 format');
     }
 
     // chromeCropImage2
@@ -39,108 +37,74 @@ function cropImageFromImageData(imageData, imageInfo) {
 
     // elementImage
     if (!imageData.elementRect) {
-        const { image, ...rest } = imageData;
-        logger.warn('missing elementRect', { ...rest });
-        return Promise.resolve({});
+        logger.warn('missing elementRect', _.omit(imageData, 'image'));
+        return {};
     }
 
     const { elementRect } = imageData;
-    return new Promise((resolve, reject) => {
-        Jimp.read(Buffer.from(imageRegExMatch[1], 'base64'), (err, image) => {
-            if (err) {
-                return reject(err);
-            }
-            try {
-                let x = elementRect.left * pixelRatio + offset.left * pixelRatio;
-                let y = elementRect.top * pixelRatio + offset.top * pixelRatio;
-                let width = elementRect.width * pixelRatio;
-                let height = elementRect.height * pixelRatio;
-
-                if (x < 0) {
-                    width += x;
-                    width = width < 0 ? 0 : width;
-                    x = 0;
-                }
+    const image = await Jimp.read(Buffer.from(imageRegExMatch[1], 'base64'));
+    let x = elementRect.left * pixelRatio + offset.left * pixelRatio;
+    let y = elementRect.top * pixelRatio + offset.top * pixelRatio;
+    let width = elementRect.width * pixelRatio;
+    let height = elementRect.height * pixelRatio;
+
+    if (x < 0) {
+        width += x;
+        width = width < 0 ? 0 : width;
+        x = 0;
+    }
 
-                if (y < 0) {
-                    height += y;
-                    height = height < 0 ? 0 : height;
-                    y = 0;
-                }
+    if (y < 0) {
+        height += y;
+        height = height < 0 ? 0 : height;
+        y = 0;
+    }
 
-                const imageWidth = image.bitmap.width;
-                const imageHeight = image.bitmap.height;
-                if ((x + width) > imageWidth) {
-                    width = imageWidth - x;
-                }
+    const imageWidth = image.bitmap.width;
+    const imageHeight = image.bitmap.height;
+    if ((x + width) > imageWidth) {
+        width = imageWidth - x;
+    }
 
-                if ((y + height) > imageHeight) {
-                    height = imageHeight - y;
-                }
+    if ((y + height) > imageHeight) {
+        height = imageHeight - y;
+    }
 
-                if (height <= 0 || width <= 0) {
-                    reject(new RectIsOutsideOfImageError('height or width is equal or lower than zero'));
-                    return undefined;
-                }
+    if (height <= 0 || width <= 0) {
+        throw new RectIsOutsideOfImageError('height or width is equal or lower than zero');
+    }
 
-                const cImage = image.crop(x, y, width, height);
-                cImage.getBase64(Jimp.MIME_PNG, (err, base64) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    resolve({
-                        elementImage: base64,
-                    });
-                    return undefined;
-                });
-                return undefined;
-            } catch (err) {
-                return reject(err);
-            }
-        });
-    });
+    const cImage = image.crop(x, y, width, height);
+    const base64 = await cImage.getBase64Async(Jimp.MIME_PNG);
+    return { elementImage: base64 };
 }
 
-
-function chromeStitchImage(fullSize, parts) {
-    return new Promise((resolve, reject) => {
-        new Jimp(fullSize.width, fullSize.height, ((err, fullImage) => {
-            if (err) {
-                reject(err);
-                return undefined;
-            }
-            return Promise.each(parts, part => new Promise((resolve, reject) => {
-                const imageRegExMatch = part.image.match(/^data\:[^;]*\;base64,(.*)$/);
-                Jimp.read(Buffer.from(imageRegExMatch[1], 'base64'), (err, partImage) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    fullImage.composite(partImage, part.position.left, part.position.top, (err, image) => {
-                        if (err) {
-                            return reject(err);
-                        }
-                        resolve(image);
-                        return undefined;
-                    });
-                    return undefined;
-                });
-            })).then(() => {
-                fullImage.getBase64(Jimp.MIME_PNG, (err, base64) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    resolve(base64);
-                    return undefined;
-                });
+async function chromeStitchImage(fullSize, parts) {
+    const fullImage = await Jimp.read(fullSize.width, fullSize.height);
+
+    for (const part of parts) {
+        const imageRegExMatch = part.image.match(/^data\:[^;]*\;base64,(.*)$/);
+        const partImage = await Jimp.read(Buffer.from(imageRegExMatch[1], 'base64'));
+        // From the code or types doesn't seem like `fullImage.composite` has an async Promise API
+        await new Promise((resolve, reject) => {
+            fullImage.composite(partImage, part.position.left, part.position.top, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
             });
-        }));
-    });
+        });
+    }
+    const base64 = await fullImage.getBase64Async(Jimp.MIME_PNG);
+    return base64;
 }
 
 function stitchImage(fullSize, parts) {
     return chromeStitchImage(fullSize, parts);
 }
 
+// ???????????
 function uploadDataUrl() {
     return Promise.resolve();
 }
@@ -175,94 +139,89 @@ function getElementAbsoluteRectangle(elementRect, pixelRatio) {
     };
 }
 
-ImageCaptureUtils.prototype = {
-    takeViewPortImage() {
-        return this.screenshotUtils.takeScreenshot()
-            .then((imageInfo) => ((typeof imageInfo === 'string') ? imageInfo : imageInfo.image));
-    },
+class ImageCaptureUtils {
+    /**
+     * @param {unknown} _unusedId
+     * @param {import('./windowUtils')} windowUtils
+     * @param {import('./screenshotUtils')} screenshotUtils
+     * */
+    constructor(_unusedId, windowUtils, screenshotUtils) {
+        this.windowUtils = windowUtils;
+        this.screenshotUtils = screenshotUtils;
+    }
+
+    async takeViewPortImage() {
+        const imageInfo = await this.screenshotUtils.takeScreenshot();
+        return ((typeof imageInfo === 'string') ? imageInfo : imageInfo.image);
+    }
 
     takeImageForComparison() {
         return this.takeViewPortImage();
-    },
+    }
 
-    takeAreaDataUrl(areas, format) {
+    async takeAreaDataUrl(areas, format) {
         // Future changes in clickim will pass parameters to this function as a single object
         if (areas.areas) {
             areas = areas.areas;
         }
 
-        return this.screenshotUtils.takeScreenshot(format)
-            .then((imageInfo) => cropImageFromImageData(areas, imageInfo).then((result) => {
-                result.screenImage = imageInfo.image;
-                result.absoluteScreenHighlight = getElementAbsoluteRectangle(
-                    areas.elementRect,
-                    imageInfo.devicePixelRatio);
-                return Promise.resolve(result);
-            }));
-    },
+        const imageInfo = await this.screenshotUtils.takeScreenshot(format);
+        const result = await cropImageFromImageData(areas, imageInfo);
+        result.screenImage = imageInfo.image;
+        result.absoluteScreenHighlight = getElementAbsoluteRectangle(areas.elementRect, imageInfo.devicePixelRatio);
+        return result;
+    }
 
-    takeArea(areas) {
+    async takeArea(areas) {
         // Future changes in clickim will pass parameters to this function as a single object
         if (areas.areas) {
             areas = areas.areas;
         }
 
-        return this.screenshotUtils.takeScreenshot()
-            .then((imageInfo) => {
-                const result = {};
-                result.screenImage = imageInfo.image;
-                result.absoluteScreenHighlight = getElementAbsoluteRectangle(
-                    areas.elementRect,
-                    imageInfo.devicePixelRatio);
-                return Promise.resolve(result);
-            }).then(uploadAllDataUrls);
-    },
+        const imageInfo = await this.screenshotUtils.takeScreenshot();
+        return uploadAllDataUrls({
+            screenImage: imageInfo.image,
+            absoluteScreenHighlight: getElementAbsoluteRectangle(areas.elementRect, imageInfo.devicePixelRatio),
+        });
+    }
 
     forcePixelRatio(forceRatio) {
         return this.screenshotUtils.forcePixelRatio(forceRatio);
-    },
+    }
 
     getCurrentDevicePixelRatio() {
         return this.screenshotUtils.getCurrentDevicePixelRatio();
-    },
+    }
 
-    takeStitchedDataUrl(useImprovedScreenshotStitching) {
-        const windowUtil = this.windowUtils;
-        const getCurrentScrollPosition = windowUtil.getCurrentScrollPosition.bind(windowUtil);
+    async takeStitchedDataUrl(useImprovedScreenshotStitching) {
+        const { windowUtils, screenshotUtils } = this;
 
-        const that = this;
-        const stabilize = () => new Promise(resolve => {
-            setTimeout(resolve, 250);
-        });
+        const stabilize = () => utils.delay(250);
         const usingImprovedStitching = Boolean(useImprovedScreenshotStitching);
-        const scroll = usingImprovedStitching ?
-            (pos) => windowUtil.scrollToPositionWithoutAnimation.bind(windowUtil)(pos) :
-            (pos) => windowUtil.scrollToPosition.bind(windowUtil)(pos);
-
-        function createPart(position, crop) {
-            return scroll(position)
-                .then(stabilize)
-                .then(() => that.screenshotUtils.takeScreenshot())
-                .then(imageInfo => {
-                    const imageData = {
-                        elementRect: crop,
-                    };
-                    return cropImageFromImageData(imageData, imageInfo);
-                })
-                .then(cropResult => ({
-                    position: { left: position.x + crop.left, top: position.y + crop.top },
-                    size: { width: crop.width, height: crop.height },
-                    image: cropResult.elementImage,
-                }));
+
+        async function createPart(position, crop) {
+            if (usingImprovedStitching) {
+                await windowUtils.scrollToPositionWithoutAnimation(position);
+            } else {
+                await windowUtils.scrollToPosition(position);
+            }
+            await stabilize();
+            const imageInfo = await screenshotUtils.takeScreenshot();
+            const cropResult = await cropImageFromImageData({ elementRect: crop }, imageInfo);
+            return ({
+                position: { left: position.x + crop.left, top: position.y + crop.top },
+                size: { width: crop.width, height: crop.height },
+                image: cropResult.elementImage,
+            });
         }
 
-        function takeAllParts(positionsData) {
-            const takeAllPartsPromises = positionsData.reduce(function (allParts, nextPos) {
-                const lastPart = allParts[allParts.length - 1];
-                allParts.push(lastPart.then(createPart.bind(this, nextPos.scrollPos, nextPos.cropData)));
-                return allParts;
-            }, [Promise.resolve()]);
-            return Promise.all(takeAllPartsPromises);
+        async function takeAllParts(positionsData) {
+            const allParts = [];
+            for (const nextPos of positionsData) {
+                const part = await createPart(nextPos.scrollPos, nextPos.cropData);
+                allParts.push(part);
+            }
+            return allParts;
         }
 
         function getPartsPositions(fullPageSize, viewPortSize) {
@@ -270,37 +229,39 @@ ImageCaptureUtils.prototype = {
             const VPW = viewPortSize.width;
             const FPH = Math.max(fullPageSize.height, viewPortSize.height);
             const VPH = viewPortSize.height;
-            const Ws = (Array.apply(null, new Array(Math.ceil(FPW / VPW)))).map((_, i) => ({
+            const Ws = Array.from({ length: Math.ceil(FPW / VPW) }, (__, i) => ({
                 scrollX: Math.min(i * VPW, FPW - VPW),
                 cropX: i * VPW - Math.min(i * VPW, FPW - VPW),
                 cropW: VPW - (i * VPW - Math.min(i * VPW, FPW - VPW)),
             }));
-            const Hs = (Array.apply(null, new Array(Math.ceil(FPH / VPH)))).map((_, i) => ({
+            const Hs = Array.from({ length: Math.ceil(FPH / VPH) }, (__, i) => ({
                 scrollY: Math.min(i * VPH, FPH - VPH),
                 cropY: i * VPH - Math.min(i * VPH, FPH - VPH),
                 cropH: VPH - (i * VPH - Math.min(i * VPH, FPH - VPH)),
             }));
-            const positions = Ws.reduce((posList, w) => posList.concat(Hs.map((h) => ({
+            return Ws.flatMap(w => Hs.map(h => ({
                 scrollPos: { x: w.scrollX, y: h.scrollY },
                 cropData: {
-                    top: h.cropY, left: w.cropX, width: w.cropW, height: h.cropH,
+                    top: h.cropY,
+                    left: w.cropX,
+                    width: w.cropW,
+                    height: h.cropH,
                 },
-            }))), []);
-            return positions;
+            }))
+            );
         }
 
         async function createStitchImage(fullPageSize, viewPortSize) {
-            const originalPosition = await getCurrentScrollPosition();
+            const originalPosition = await windowUtils.getCurrentScrollPosition();
             const positions = getPartsPositions(fullPageSize, viewPortSize);
             const parts = await takeAllParts(positions);
-            await windowUtil.scrollToPosition(originalPosition);
-            parts.shift();
+            await windowUtils.scrollToPosition(originalPosition);
             return stitchImage(fullPageSize, parts);
         }
 
-        return Promise.all([windowUtil.getFullPageSize(), windowUtil.getViewportSize()])
-            .then(([fullPageSize, viewPortSize]) => createStitchImage(fullPageSize, viewPortSize));
-    },
-};
+        const [fullPageSize, viewPortSize] = await Promise.all([windowUtils.getFullPageSize(), windowUtils.getViewportSize()]);
+        return await createStitchImage(fullPageSize, viewPortSize);
+    }
+}
 
 module.exports = ImageCaptureUtils;

package/player/utils/screenshotUtils.js

@@ -1,9 +1,15 @@
+// @ts-check
+
 'use strict';
 
 const Promise = require('bluebird');
 const pRetry = require('p-retry');
 
 class ScreenshotUtils {
+    /**
+     * @param {any} tabId
+     * @param {import('../webdriver')} driver
+     */
     constructor(tabId, driver, options = { takeScreenshots: true }) {
         this.tabId = tabId;
         this.driver = driver;
@@ -21,23 +27,21 @@ class ScreenshotUtils {
         return this.options.takeScreenshots;
     }
 
-    takeScreenshot() {
+    async takeScreenshot() {
         if (!this.shouldTakeScreenshots()) {
-            return Promise.resolve({ devicePixelRatio: 1, image: '' });
+            return { devicePixelRatio: 1, image: '' };
         }
         const MAX_RETRY_COUNT = 3;
         const SCREENSHOT_RETRY_DELAY = 2000;
         const devicePixelRatioPromise = this.currentDevicePixelRatio ? Promise.resolve(this.currentDevicePixelRatio) : this.getDevicePixelRatio();
         const getScreenshot = () => Promise.all([devicePixelRatioPromise, this.driver.takeScreenshot()]);
-        return pRetry(getScreenshot, { retries: MAX_RETRY_COUNT, minTimeout: SCREENSHOT_RETRY_DELAY })
-            .then(([devicePixelRatio, image]) => {
-                const base64 = image ? image.value : '';
-                const dataUrl = `data:image/png;base64,${this.base64AddPadding(base64.replace(/[\r\n]/g, ''))}`;
-                return {
-                    image: dataUrl,
-                    devicePixelRatio,
-                };
-            });
+        const [devicePixelRatio, image] = await pRetry(getScreenshot, { retries: MAX_RETRY_COUNT, minTimeout: SCREENSHOT_RETRY_DELAY });
+        const base64 = image ? image.value : '';
+        const dataUrl = `data:image/png;base64,${this.base64AddPadding(base64.replace(/[\r\n]/g, ''))}`;
+        return {
+            image: dataUrl,
+            devicePixelRatio,
+        };
     }
 
     getDevicePixelRatio() {
@@ -49,7 +53,7 @@ class ScreenshotUtils {
             }
         }
 
-        return this.driver.executeJS(devicePixelRatioJS).then(result => Promise.resolve(result.value));
+        return this.driver.executeJS(devicePixelRatioJS).then(result => result.value);
     }
 
     forcePixelRatio(forceRatio = 1) {
@@ -63,4 +67,3 @@ class ScreenshotUtils {
 }
 
 module.exports = ScreenshotUtils;
-

package/player/utils/windowUtils.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 'use strict';
 
 const Promise = require('bluebird');
@@ -7,6 +9,10 @@ const { PageNotAvailableError } = require('../../errors');
 const logger = require('../../commons/logger').getLogger('window-utils');
 
 class WindowUtils {
+    /**
+     * @param {number} id tab or worker id
+     * @param {import('../webdriver')} driver
+     * */
     constructor(id, driver) {
         this.id = id;
         this.driver = driver;
@@ -131,12 +137,12 @@ class WindowUtils {
             });
     }
 
-    setViewportSize(size) {
-        return this.driver.setViewportSize(size.width, size.height)
-            .then(() => this.checkSize(size));
+    async setViewportSize(size) {
+        await this.driver.setViewportSize(size.width, size.height);
+        return await this.checkSize(size);
     }
 
-    validatePageIsAvailable() {
+    async validatePageIsAvailable() {
         /* eslint-disable */
         function pageIsAvailable() {
             var locationObj;
@@ -153,7 +159,8 @@ class WindowUtils {
         }
         /* eslint-enable */
 
-        return this.driver.executeJS(pageIsAvailable).then(result => (result.value ? Promise.resolve() : Promise.reject(new PageNotAvailableError())));
+        const result = await this.driver.executeJS(pageIsAvailable);
+        return await (result.value ? Promise.resolve() : Promise.reject(new PageNotAvailableError()));
     }
 
     focusTab() {
@@ -164,9 +171,14 @@ class WindowUtils {
         return undefined;
     }
 
-    getOsAndBrowser() {
-        return pRetry(() => this.driver.getBrowserAndOS(), { retries: 3 })
-            .then(osAndBrowser => ({ uaBrowserName: osAndBrowser.browser, uaOs: osAndBrowser.os, userAgent: osAndBrowser.userAgent, browserVersion: osAndBrowser.browserVersion }));
+    async getOsAndBrowser() {
+        const osAndBrowser = await pRetry(() => this.driver.getBrowserAndOS(), { retries: 3 });
+        return {
+            uaBrowserName: osAndBrowser.browser,
+            uaOs: osAndBrowser.os,
+            userAgent: osAndBrowser.userAgent,
+            browserVersion: osAndBrowser.browserVersion,
+        };
     }
 
     getUserAgentInfo() {