@applitools/eyes-cypress 3.31.0 → 3.32.0

package/CHANGELOG.md

@@ -12,6 +12,18 @@
 
 
 
+## 3.32.0 - 2023/4/21
+
+### Features
+- Add a timeout and max concurrency for fetching resources
+### Bug fixes
+
+## 3.31.1 - 2023/4/14
+
+### Features
+### Bug fixes
+- Map values from open and global config
+
 ## 3.31.0 - 2023/4/4
 
 ### Features

package/dist/browser/mergeCypressConfigs.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeCypressConfigs = void 0;
+function mergeCypressConfigs({ globalConfig, openConfig, }) {
+    return {
+        ...globalConfig,
+        ...openConfig,
+        batch: { ...globalConfig.batch, ...openConfig.batch },
+    };
+}
+exports.mergeCypressConfigs = mergeCypressConfigs;

package/dist/browser/transformCypressCheckSettings.js

@@ -0,0 +1,281 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformCypressCheckSettings = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const utils_1 = require("./utils");
+function transformCypressCheckSettings(settings, refer) {
+    if (utils.types.isString(settings)) {
+        return { name: settings };
+    }
+    const target = settings.target === 'region' ? transformTargetRegion(settings) : undefined;
+    return {
+        renderers: (0, utils_1.transformBrowsers)(settings.browser),
+        hooks: settings.scriptHooks,
+        disableBrowserFetching: settings.disableBrowserFetching,
+        layoutBreakpoints: settings.layoutBreakpoints,
+        ufgOptions: settings.visualGridOptions,
+        name: settings.tag,
+        ignoreRegions: transformRegionsWithOptions(settings.ignore),
+        floatingRegions: convertFloatingRegion(settings.floating),
+        strictRegions: transformRegionsWithOptions(settings.strict),
+        contentRegions: transformRegionsWithOptions(settings.content),
+        layoutRegions: transformRegionsWithOptions(settings.layout),
+        accessibilityRegions: convertAccessabilityRegions(settings.accessibility),
+        userCommandId: settings.variationGroupId,
+        region: utils.types.has(target, 'region') ? target.region : undefined,
+        ignoreCaret: settings.ignoreCaret,
+        ignoreDisplacements: settings.ignoreDisplacements,
+        fully: settings.fully,
+        waitBeforeCapture: settings.waitBeforeCapture,
+        lazyLoad: settings.lazyLoad,
+        matchLevel: settings.matchLevel,
+        useDom: settings.useDom,
+        sendDom: settings.sendDom,
+        enablePatterns: settings.enablePatterns,
+        pageId: settings.pageId,
+    };
+    function transformTargetRegion(checkSettings) {
+        const shadowDomSettings = {};
+        let regionSettings = {};
+        if (!Array.isArray(checkSettings.selector)) {
+            if (utils.types.has(checkSettings, 'element')) {
+                if (isHTMLElement(checkSettings.element)) {
+                    regionSettings = {
+                        region: Object.assign(refer.ref(checkSettings.element), { type: 'element' }),
+                    };
+                }
+                else if (utils.types.has(checkSettings.element, [0])) {
+                    regionSettings = {
+                        region: Object.assign(refer.ref(checkSettings.element[0]), { type: 'element' }),
+                    };
+                }
+            }
+            else if (utils.types.has(checkSettings, 'region') &&
+                utils.types.has(checkSettings.region, 'top') &&
+                utils.types.has(checkSettings.region, 'left') &&
+                utils.types.has(checkSettings.region, 'width') &&
+                utils.types.has(checkSettings.region, 'height')) {
+                regionSettings = {
+                    region: {
+                        y: checkSettings.region.top,
+                        x: checkSettings.region.left,
+                        width: checkSettings.region.width,
+                        height: checkSettings.region.height,
+                    },
+                };
+            }
+            else if (!utils.types.has(checkSettings, 'selector')) {
+                regionSettings = {
+                    region: checkSettings.region,
+                };
+            }
+            else {
+                regionSettings = {
+                    region: checkSettings.selector,
+                };
+            }
+        }
+        else {
+            const selectors = checkSettings.selector;
+            for (let i = selectors.length - 1; i > -1; i--) {
+                if (i === selectors.length - 1) {
+                    shadowDomSettings['shadow'] = selectors[i].selector;
+                }
+                else {
+                    const prevSettings = Object.assign({}, shadowDomSettings);
+                    shadowDomSettings['selector'] = selectors[i].selector;
+                    if (!prevSettings.hasOwnProperty('selector')) {
+                        shadowDomSettings['shadow'] = prevSettings.shadow;
+                    }
+                    else {
+                        shadowDomSettings['shadow'] = prevSettings;
+                    }
+                }
+            }
+            regionSettings = { region: shadowDomSettings };
+        }
+        return regionSettings;
+    }
+    function convertAccessabilityRegions(accessibilityRegions) {
+        if (!accessibilityRegions)
+            return;
+        if (!Array.isArray(accessibilityRegions)) {
+            accessibilityRegions = [accessibilityRegions];
+        }
+        const accessibility = [];
+        for (const region of accessibilityRegions) {
+            const accessabilityRegion = {
+                type: utils.types.has(region, 'accessibilityType') ? region.accessibilityType : undefined,
+            };
+            if (utils.types.has(region, 'selector')) {
+                const currRegion = { ...accessabilityRegion, region: region.selector };
+                delete region.selector;
+                accessibility.push(currRegion);
+            }
+            else if (utils.types.has(region, 'element')) {
+                const elements = refElements(region.element);
+                delete region['element'];
+                for (const element of elements) {
+                    accessibility.push(Object.assign({}, region, accessabilityRegion, { region: element }));
+                }
+            }
+            else if (utils.types.has(region, 'region')) {
+                const currRegion = { ...region, type: region.region.accessibilityType };
+                delete currRegion.region.accessibilityType;
+                accessibility.push(currRegion);
+            }
+            else if (utils.types.has(region, 'top')) {
+                accessibility.push({
+                    ...accessabilityRegion,
+                    region: { y: region.top, x: region.left, width: region.width, height: region.height },
+                });
+            }
+            else {
+                accessibility.push(region);
+            }
+        }
+        return accessibility;
+    }
+    function convertFloatingRegion(floatingRegions) {
+        if (!floatingRegions)
+            return;
+        if (!Array.isArray(floatingRegions)) {
+            floatingRegions = [floatingRegions];
+        }
+        const floating = [];
+        for (const region of floatingRegions) {
+            const floatingRegion = {
+                offset: {
+                    bottom: region.maxDownOffset || 0,
+                    left: region.maxLeftOffset || 0,
+                    top: region.maxUpOffset || 0,
+                    right: region.maxRightOffset || 0,
+                },
+            };
+            delete region.maxDownOffset;
+            delete region.maxLeftOffset;
+            delete region.maxUpOffset;
+            delete region.maxRightOffset;
+            if (utils.types.has(region, 'selector')) {
+                const currRegion = { region: region.selector, ...region, ...floatingRegion };
+                delete currRegion.selector;
+                floating.push(currRegion);
+            }
+            else if (utils.types.has(region, 'element')) {
+                const elements = refElements(region.element);
+                delete region.element;
+                for (const element of elements) {
+                    floating.push({ ...region, ...floatingRegion, region: element });
+                }
+            }
+            else if (utils.types.has(region, 'region')) {
+                const currRegion = { offset: floatingRegion.offset, ...region };
+                floating.push(currRegion);
+            }
+            else if (utils.types.has(region, 'top')) {
+                floating.push({
+                    ...floatingRegion,
+                    region: {
+                        y: region.top,
+                        x: region.left,
+                        width: region.width,
+                        height: region.height,
+                    },
+                });
+            }
+            else {
+                floating.push(region);
+            }
+        }
+        return floating;
+    }
+    function transformRegionsWithOptions(regions) {
+        if (!regions)
+            return;
+        if (!Array.isArray(regions))
+            regions = [regions];
+        let resRegions = [];
+        for (const region of regions) {
+            if (utils.types.has(region, 'element')) {
+                if (utils.types.has(region, 'padding') || utils.types.has(region, 'regionId')) {
+                    const currRefElements = refElements(region.element);
+                    for (const refElement of currRefElements) {
+                        const curr = { region: refElement };
+                        if (region.padding) {
+                            curr.padding = region.padding;
+                        }
+                        if (region.regionId) {
+                            curr.regionId = region.regionId;
+                        }
+                        resRegions.push(curr);
+                    }
+                }
+                else {
+                    resRegions = [...resRegions, ...refElements(region.element)];
+                }
+            }
+            else if (isHTMLElement(region) || utils.types.has(region, 'jquery')) {
+                resRegions = [...resRegions, ...refElements(region)];
+            }
+            else {
+                if (utils.types.has(region, 'selector') && !utils.types.has(region, 'type')) {
+                    const currRegion = { region: region.selector, ...region };
+                    delete currRegion.selector;
+                    resRegions.push(currRegion);
+                }
+                else {
+                    resRegions.push(region);
+                }
+            }
+        }
+        return resRegions;
+    }
+    function refElements(regions) {
+        if (!regions)
+            return;
+        if (!Array.isArray(regions))
+            regions = [regions];
+        const elements = [];
+        for (const region of regions) {
+            if (isHTMLElement(region)) {
+                elements.push(Object.assign(refer.ref(region), { type: 'element' }));
+            }
+            else if (utils.types.has(region, 'jquery')) {
+                region.each(function () {
+                    elements.push(isHTMLElement(this) ? Object.assign(refer.ref(this), { type: 'element' }) : this);
+                });
+            }
+            else {
+                elements.push(region);
+            }
+        }
+        return elements;
+    }
+    function isHTMLElement(element) {
+        return utils.types.has(element, 'nodeType') && element.nodeType === Node.ELEMENT_NODE;
+    }
+}
+exports.transformCypressCheckSettings = transformCypressCheckSettings;

package/dist/browser/transformCypressConfig.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformCypressConfig = void 0;
+const utils_1 = require("./utils");
+function transformCypressConfig(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return {
+        open: {
+            apiKey: config.apiKey,
+            serverUrl: config.serverUrl,
+            proxy: config.proxy,
+            appName: config.appName,
+            testName: config.testName,
+            displayName: config.displayName,
+            batch: {
+                ...config.batch,
+                id: (_a = config.batchId) !== null && _a !== void 0 ? _a : (_b = config.batch) === null || _b === void 0 ? void 0 : _b.id,
+                name: (_c = config.batchName) !== null && _c !== void 0 ? _c : (_d = config.batch) === null || _d === void 0 ? void 0 : _d.name,
+                sequenceName: (_e = config.batchSequenceName) !== null && _e !== void 0 ? _e : (_f = config.batch) === null || _f === void 0 ? void 0 : _f.sequenceName,
+                notifyOnCompletion: (_g = config.notifyOnCompletion) !== null && _g !== void 0 ? _g : (_h = config.batch) === null || _h === void 0 ? void 0 : _h.notifyOnCompletion,
+            },
+            keepBatchOpen: !config.shouldUseBrowserHooks,
+            environmentName: config.envName,
+            baselineBranchName: config.baselineBranchName,
+            branchName: config.branchName,
+            parentBranchName: config.parentBranchName,
+            compareWithParentBranch: config.compareWithParentBranch,
+            ignoreBaseline: config.ignoreBaseline,
+            ignoreGitBranching: config.ignoreGitMergeBase,
+            saveDiffs: config.saveDiffs,
+            properties: config.properties,
+            environment: {
+                viewportSize: config.viewportSize,
+            },
+        },
+        check: {
+            renderers: (0, utils_1.transformBrowsers)(config.browser),
+            matchLevel: config.matchLevel,
+            ignoreCaret: config.ignoreCaret,
+            ignoreDisplacements: config.ignoreDisplacements,
+            accessibilitySettings: (0, utils_1.transformAccessibilityValidation)(config.accessibilityValidation),
+            layoutBreakpoints: config.layoutBreakpoints,
+            sendDom: config.sendDom,
+            useDom: config.useDom,
+            enablePatterns: config.enablePatterns,
+            ufgOptions: config.visualGridOptions,
+            disableBrowserFetching: config.disableBrowserFetching,
+            hooks: config.scriptHooks,
+        },
+        screenshot: {
+            waitBeforeCapture: config.waitBeforeCapture,
+        },
+        close: {
+            updateBaselineIfNew: config.saveNewTests,
+        },
+    };
+}
+exports.transformCypressConfig = transformCypressConfig;

package/dist/browser/utils.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAccessibilityValidation = exports.transformBrowsers = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function transformBrowsers(browsers) {
+    if (!browsers)
+        return;
+    if (!Array.isArray(browsers))
+        browsers = [browsers];
+    return browsers.map(browser => {
+        if (utils.types.has(browser, 'width') && utils.types.has(browser, 'height') && !utils.types.has(browser, 'name')) {
+            browser.name = 'chrome';
+            return browser;
+        }
+        else if (utils.types.has(browser, 'deviceName')) {
+            return { chromeEmulationInfo: browser };
+        }
+        else {
+            return browser;
+        }
+    });
+}
+exports.transformBrowsers = transformBrowsers;
+function transformAccessibilityValidation(accessibilityValidation) {
+    if (!accessibilityValidation)
+        return;
+    return {
+        level: accessibilityValidation.level,
+        version: accessibilityValidation.guidelinesVersion,
+    };
+}
+exports.transformAccessibilityValidation = transformAccessibilityValidation;

package/dist/plugin/config.js

@@ -40,6 +40,8 @@ function makeConfig() {
             'disableBrowserFetching',
             'testConcurrency',
             'removeDuplicateTests',
+            'eyesFetchConcurrency',
+            'universalDebug',
         ],
     });
     if ((!config.batch || !config.batch.id) && !config.batchId) {
@@ -69,6 +71,7 @@ function makeConfig() {
         eyesTestConcurrency: config.testConcurrency || DEFAULT_TEST_CONCURRENCY,
         eyesWaitBeforeCapture: config.waitBeforeCapture,
         eyesRemoveDuplicateTests: !!config.removeDuplicateTests,
+        universalDebug: !!config.universalDebug,
     };
     return { config, eyesConfig };
 }

package/dist/plugin/server.js

@@ -40,6 +40,7 @@ function makeStartServer({ logger, eyesConfig }) {
             forkOptions,
             singleton: false,
             portResolutionMode: 'random',
+            debug: eyesConfig.universalDebug,
         });
         const managers = [];
         let socketWithUniversal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/eyes-cypress",
-  "version": "3.31.0",
+  "version": "3.32.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/applitools/eyes.sdk.javascript1.git",
@@ -27,14 +27,14 @@
   ],
   "scripts": {
     "lint": "eslint \"**/*.{js,ts}\"",
-    "build": "ttsc",
+    "build": "node ../../node_modules/.bin/ttsc",
     "generate:tests": "coverage-tests generate",
     "test": "yarn test:unit && yarn test:it && yarn test:e2e && yarn test:ts && yarn test:components && yarn test:coverage",
     "test:sanity": "yarn test:unit && yarn test:it && yarn test:ts",
     "test:unit": "mocha --no-timeouts 'test/unit/**/*.test.js'",
     "test:it": "yarn build && mocha --no-timeouts 'test/it/**/*.test.js'",
     "test:ts": "yarn test:ts:compile && yarn test:ts:run",
-    "test:ts:compile": "tsc --project test/e2e/ts/cypress",
+    "test:ts:compile": "node ../../node_modules/.bin/tsc --project test/e2e/ts/cypress",
     "test:ts:run:legacy": "yarn cypress9 run --config-file ./test/e2e/ts/cypress-ts-legacy.json",
     "cypress8": "./node_modules/cypress8/bin/cypress",
     "test:ts:run:8": "yarn cypress8 run --project ./test/e2e/ts --config-file ./cypress-8.config.ts",
@@ -69,7 +69,7 @@
     }
   },
   "dependencies": {
-    "@applitools/core": "2.4.7",
+    "@applitools/core": "2.5.3",
     "@applitools/eyes-api": "1.13.12",
     "@applitools/functional-commons": "1.6.0",
     "@applitools/logger": "1.1.48",
@@ -82,12 +82,12 @@
     "ws": "8.5.0"
   },
   "devDependencies": {
-    "@applitools/api-extractor": "^1.2.12",
+    "@applitools/api-extractor": "^1.2.14",
     "@applitools/bongo": "^3.0.3",
-    "@applitools/sdk-coverage-tests": "^3.0.0",
+    "@applitools/sdk-coverage-tests": "^3.0.2",
     "@applitools/snaptdout": "1.0.1",
     "@applitools/test-server": "1.1.28",
-    "@applitools/test-utils": "1.5.15",
+    "@applitools/test-utils": "1.5.16",
     "@types/node": "12",
     "@types/semver": "^7.3.13",
     "@types/uuid": "^9.0.0",
@@ -110,9 +110,7 @@
     "morgan": "1.9.1",
     "ncp": "2.0.0",
     "node-fetch": "2.6.0",
-    "prettier": "^2.6.2",
-    "ttypescript": "^1.5.13",
-    "typescript": "^4.7.2"
+    "prettier": "^2.6.2"
   },
   "engines": {
     "node": ">=12.13.0"

package/src/browser/commands.js

@@ -4,12 +4,13 @@ const spec = require('../../dist/browser/spec-driver')
 const Refer = require('./refer')
 const Socket = require('./socket')
 const {socketCommands} = require('./socketCommands')
-const {eyesOpenMapValues, eyesOpenToCheckMapValues} = require('./eyesOpenMapping')
-const {eyesCheckMapValues} = require('./eyesCheckMapping')
 const {TestResultsSummary} = require('@applitools/eyes-api')
 const refer = new Refer()
 const socket = new Socket()
 const throwErr = Cypress.config('failCypressOnDiff')
+const {transformCypressConfig} = require('../../dist/browser/transformCypressConfig')
+const {mergeCypressConfigs} = require('../../dist/browser/mergeCypressConfigs')
+const {transformCypressCheckSettings} = require('../../dist/browser/transformCypressCheckSettings')
 socketCommands(socket, refer)
 
 let manager,
@@ -17,7 +18,7 @@ let manager,
   closePromiseArr = [],
   _summary,
   connectedToUniversal,
-  openToCheckSettingsArgs
+  openAndGlobalConfig
 
 async function getSummary() {
   if (_summary) return _summary
@@ -133,21 +134,15 @@ Cypress.Commands.add('eyesOpen', function (args = {}) {
         (await socket.request('Core.makeManager', {
           concurrency: Cypress.config('eyesTestConcurrency'),
           type: 'ufg',
+          fetchConcurrency: Cypress.config('appliConfFile').eyesFetchConcurrency,
         }))
     }
 
     const appliConfFile = Cypress.config('appliConfFile')
+    const mergedConfig = mergeCypressConfigs({globalConfig: appliConfFile, openConfig: {testName, ...args}})
+    openAndGlobalConfig = transformCypressConfig({...mergedConfig, shouldUseBrowserHooks})
 
-    openToCheckSettingsArgs = eyesOpenToCheckMapValues(args)
-
-    const settings = eyesOpenMapValues({
-      args,
-      appliConfFile,
-      testName,
-      shouldUseBrowserHooks,
-    })
-
-    eyes = await socket.request('EyesManager.openEyes', {manager, target, settings})
+    eyes = await socket.request('EyesManager.openEyes', {manager, target, config: openAndGlobalConfig})
   })
 })
 
@@ -160,16 +155,13 @@ Cypress.Commands.add('eyesCheckWindow', (args = {}) =>
 
     Cypress.log({name: 'Eyes: check window'})
 
-    const settings = eyesCheckMapValues({
-      args: {...openToCheckSettingsArgs, ...args},
-      refer,
-      appliConfFile: Cypress.config('appliConfFile'),
-    })
+    const settings = transformCypressCheckSettings(args, refer)
 
     return socket.request('Eyes.check', {
       eyes,
       settings,
       target,
+      config: openAndGlobalConfig,
     })
   }),
 )
@@ -185,7 +177,7 @@ Cypress.Commands.add('eyesClose', () => {
     }
 
     // Eyes.close in core is not waiting on results anymore. So we should return it in order to await it
-    const p = socket.request('Eyes.close', {eyes}).catch(err => {
+    const p = socket.request('Eyes.close', {eyes, config: openAndGlobalConfig}).catch(err => {
       console.log('Error in cy.eyesClose', err)
     })
     closePromiseArr.push(p)
@@ -193,6 +185,14 @@ Cypress.Commands.add('eyesClose', () => {
   })
 })
 
+// internal command //
+Cypress.Commands.add('debugHistory', async function () {
+  Cypress.log({name: 'Debug: history'})
+  const history = await socket.request('Debug.getHistory')
+
+  return history
+})
+
 function setRootContext() {
   cy.state('window').document['applitools-marker'] = 'root-context'
 }

package/src/browser/mergeCypressConfigs.ts

@@ -0,0 +1,15 @@
+import type {CypressEyesConfig} from '../expose'
+
+export function mergeCypressConfigs({
+  globalConfig,
+  openConfig,
+}: {
+  globalConfig: CypressEyesConfig
+  openConfig: CypressEyesConfig
+}): CypressEyesConfig {
+  return {
+    ...globalConfig,
+    ...openConfig,
+    batch: {...globalConfig.batch, ...openConfig.batch},
+  }
+}