@applitools/nml-client 1.1.0 → 1.2.0

package/dist/client.js

@@ -23,32 +23,67 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.takeSnapshot = exports.takeScreenshot = void 0;
-const broker_1 = require("./broker");
+exports.takeSnapshots = exports.takeScreenshot = void 0;
+const logger_1 = require("@applitools/logger");
+const req_broker_1 = require("./req-broker");
 const utils = __importStar(require("@applitools/utils"));
-async function takeScreenshot(url, options) {
-    if (options && options.logger)
-        options.logger.log('[nml-client]: takeScreenshot called with', url, options);
-    const request = {
-        protocolVersion: '1.0',
-        name: 'TAKE_SCREENSHOT',
-        key: utils.general.guid(),
-        payload: options && options.settings,
+async function takeScreenshot({ url, settings, logger, }) {
+    var _a;
+    logger = (_a = logger === null || logger === void 0 ? void 0 : logger.extend({ label: 'nml client' })) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ label: 'nml client' });
+    const req = (0, req_broker_1.makeReqBroker)({ config: settings, logger });
+    const payload = {
+        name: settings.name,
+        screenshotMode: settings.fully ? 'FULL_RESIZE' : 'VIEWPORT',
+        scrollRootElement: settings.scrollRootElement,
+        hideCaret: settings.hideCaret,
+        waitBeforeCapture: settings.waitBeforeCapture,
+        overlap: settings.overlap,
+        selectorsToFindRegionsFor: [],
     };
-    const { screenshotURL } = await (0, broker_1.broker)(url, request, { proxy: options && options.proxy });
-    return screenshotURL;
+    const response = await req(url, {
+        name: 'TAKE_SCREENSHOT',
+        body: {
+            protocolVersion: '1.0',
+            name: 'TAKE_SCREENSHOT',
+            key: utils.general.guid(),
+            payload,
+        },
+        logger,
+    });
+    const result = await response.json();
+    return result.payload;
 }
 exports.takeScreenshot = takeScreenshot;
-async function takeSnapshot(url, options) {
-    if (options && options.logger)
-        options.logger.log('[nml-client]: takeSnapshot called with', url, options);
-    const request = {
-        protocolVersion: '1.0',
-        name: 'TAKE_SNAPSHOT',
-        key: utils.general.guid(),
-        payload: options && options.settings,
+async function takeSnapshots({ url, settings, logger, }) {
+    var _a;
+    logger = (_a = logger === null || logger === void 0 ? void 0 : logger.extend({ label: 'nml client' })) !== null && _a !== void 0 ? _a : (0, logger_1.makeLogger)({ label: 'nml client' });
+    const req = (0, req_broker_1.makeReqBroker)({ config: settings, logger });
+    const payload = {
+        waitBeforeCapture: settings.waitBeforeCapture,
     };
-    const result = await (0, broker_1.broker)(url, request, { proxy: options && options.proxy });
-    return result;
+    const response = await req(url, {
+        name: 'TAKE_SNAPSHOT',
+        body: {
+            protocolVersion: '1.0',
+            name: 'TAKE_SNAPSHOT',
+            key: utils.general.guid(),
+            payload,
+        },
+    });
+    const snapshot = await response.json().then(({ payload }) => {
+        const { resourceMap, metadata } = payload.result;
+        const platformName = resourceMap.metadata.platformName;
+        return {
+            platformName,
+            vhsHash: resourceMap.vhs,
+            vhsCompatibilityParams: platformName === 'ios'
+                ? {
+                    UIKitLinkTimeVersionNumber: metadata.UIKitLinkTimeVersionNumber,
+                    UIKitRunTimeVersionNumber: metadata.UIKitRunTimeVersionNumber,
+                }
+                : undefined,
+        };
+    });
+    return Array(settings.renderers.length).fill(snapshot);
 }
-exports.takeSnapshot = takeSnapshot;
+exports.takeSnapshots = takeSnapshots;

package/dist/req-broker.js

@@ -0,0 +1,95 @@
+"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.makeReqBroker = void 0;
+const req_1 = __importStar(require("@applitools/req"));
+function makeReqBroker({ config, logger }) {
+    return (0, req_1.makeReq)({
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': config.agentId,
+        },
+        proxy: config.proxy,
+        timeout: 300000 /* 5min */,
+        retry: {
+            limit: 5,
+            timeout: 200,
+            codes: ['ECONNRESET', 'ECONNABORTED', 'ETIMEDOUT', 'ENOTFOUND', 'EAI_AGAIN'],
+        },
+        hooks: [handleLogs({ logger }), handleLongRequests({ req: req_1.default }), handleUnexpectedResponse()],
+    });
+}
+exports.makeReqBroker = makeReqBroker;
+function handleLogs({ logger: defaultLogger } = {}) {
+    return {
+        beforeRequest({ request, options }) {
+            var _a;
+            const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : defaultLogger;
+            logger === null || logger === void 0 ? void 0 : logger.log(`Broker request "${options.name}" will be sent to the address "[${request.method}]${request.url}" with body`, options.body);
+        },
+        async afterResponse({ request, response, options }) {
+            var _a;
+            const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : defaultLogger;
+            logger === null || logger === void 0 ? void 0 : logger.log(`Broker request "${options.name}" that was sent to the address "[${request.method}]${request.url}" respond with ${response.statusText}(${response.status})`, response.status !== 200 ? `and body ${JSON.stringify(await response.clone().text())}` : '');
+        },
+        afterError({ request, error, options }) {
+            var _a;
+            const logger = (_a = options.logger) !== null && _a !== void 0 ? _a : defaultLogger;
+            logger === null || logger === void 0 ? void 0 : logger.error(`Broker request "${options.name}" that was sent to the address "[${request.method}]${request.url}" failed with error`, error);
+        },
+    };
+}
+function handleLongRequests({ req }) {
+    return {
+        async afterResponse({ request, response, options }) {
+            if (response.status === 200) {
+                return req(request.url + '-response', {
+                    proxy: options.proxy,
+                    retry: { statuses: [404] },
+                });
+            }
+        },
+    };
+}
+function handleUnexpectedResponse() {
+    return {
+        async afterResponse({ response }) {
+            var _a;
+            if (response.status !== 200) {
+                throw new Error(`Something went wrong when communicating with the mobile application, please try running your test again (error code: ${response.status})`);
+            }
+            else {
+                const body = await response.text();
+                const result = JSON.parse(body);
+                if ((_a = result === null || result === void 0 ? void 0 : result.payload) === null || _a === void 0 ? void 0 : _a.error) {
+                    const error = result.payload.error;
+                    throw new Error(`There was a problem when interacting with the mobile application. The provided error message was "${error.message}" and had a stack trace of "${error.stack}"`);
+                }
+                return new req_1.Response(body, response);
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/nml-client",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Client to integrate the SDKs to the Native Mobile Library (NML)",
   "homepage": "https://applitools.com",
   "bugs": {
@@ -46,13 +46,15 @@
     "postversion": "bongo postversion --skip-release-notification"
   },
   "dependencies": {
-    "@applitools/req": "1.1.0",
-    "@applitools/utils": "1.3.10"
+    "@applitools/logger": "1.1.17",
+    "@applitools/req": "1.1.2",
+    "@applitools/types": "1.5.10",
+    "@applitools/utils": "1.3.11"
   },
   "devDependencies": {
     "@applitools/bongo": "^2.2.0",
     "@applitools/scripts": "^1.1.0",
-    "@applitools/spec-driver-selenium": "^1.3.17",
+    "@applitools/spec-driver-selenium": "^1.3.19",
     "@applitools/test-server": "^1.1.4",
     "@applitools/test-utils": "^1.5.1",
     "@types/mocha": "^9.1.1",

package/types/client.d.ts

@@ -1,11 +1,25 @@
-import { ScreenshotSettings, SnapshotSettings } from './broker';
-export declare function takeScreenshot(url: any, options?: {
-    settings?: ScreenshotSettings;
-    proxy?: any;
-    logger?: any;
-}): Promise<string>;
-export declare function takeSnapshot(url: string, options?: {
-    settings?: SnapshotSettings;
-    proxy?: any;
-    logger?: any;
-}): Promise<any>;
+import type { Selector, Renderer } from '@applitools/types';
+import type { Screenshot, ScreenshotSettings as ClassicScreenshotSettings } from '@applitools/types/classic';
+import type { AndroidVHS, IOSVHS } from '@applitools/types/ufg';
+import { type Logger } from '@applitools/logger';
+import { type ReqBrokerConfig } from './req-broker';
+export declare type ScreenshotSettings = ReqBrokerConfig & ClassicScreenshotSettings<never, never> & {
+    name?: string;
+    selectorsToFindRegionsFor?: Selector[];
+};
+export declare type SnapshotSettings = ReqBrokerConfig & {
+    name?: string;
+    renderers: Renderer[];
+    resourceSeparation?: boolean;
+    waitBeforeCapture?: number;
+};
+export declare function takeScreenshot({ url, settings, logger, }: {
+    url: string;
+    settings: ScreenshotSettings;
+    logger?: Logger;
+}): Promise<Screenshot>;
+export declare function takeSnapshots({ url, settings, logger, }: {
+    url: string;
+    settings: SnapshotSettings;
+    logger?: Logger;
+}): Promise<IOSVHS[] | AndroidVHS[]>;

package/types/req-broker.d.ts

@@ -0,0 +1,22 @@
+import type { Proxy } from '@applitools/types';
+import { type Logger } from '@applitools/logger';
+import { type Req, type Options } from '@applitools/req';
+export declare type ReqBrokerConfig = {
+    proxy?: Proxy;
+    agentId?: string;
+};
+export declare type ReqBrokerOptions = Options & {
+    name: string;
+    body: {
+        protocolVersion: '1.0';
+        name: string;
+        key: string;
+        payload: Record<string, any>;
+    };
+    logger?: Logger;
+};
+export declare type ReqBroker = Req<ReqBrokerOptions>;
+export declare function makeReqBroker({ config, logger }: {
+    config: ReqBrokerConfig;
+    logger?: Logger;
+}): Req<ReqBrokerOptions>;

package/dist/broker.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.broker = exports.publishMessageRequest = void 0;
-const req_1 = require("@applitools/req");
-async function publishMessageRequest(options) {
-    const response = await (0, req_1.req)(options.url, {
-        method: 'POST',
-        body: options.payload,
-        headers: { 'Content-Type': 'application/json' },
-        proxy: options.proxy,
-        hooks: {
-            afterResponse: async (response) => {
-                if (response.response.status != 200)
-                    return;
-                return (0, req_1.req)(options.url + '-response', {
-                    retry: [{ statuses: [404] }],
-                });
-            },
-        },
-    });
-    if (response.status !== 200) {
-        throw new Error(`something went wrong when communicating with the mobile application, please try running your test again (error code: ${response.status})`);
-    }
-    return response;
-}
-exports.publishMessageRequest = publishMessageRequest;
-async function broker(url, request, options) {
-    const response = await publishMessageRequest({
-        url,
-        payload: request,
-        ...options,
-    });
-    const { payload } = await response.json();
-    if (!payload || (payload && payload.error))
-        throw new Error(`There was a problem when interacting with the mobile application. The provided error message was "${payload.error.message}" and had a stack trace of "${payload.error.stack}"`);
-    return payload.result;
-}
-exports.broker = broker;

package/types/broker.d.ts

@@ -1,35 +0,0 @@
-export declare function publishMessageRequest(options: {
-    url: string;
-    payload: any;
-    proxy?: any;
-}): Promise<any>;
-declare type CommonSelector = {
-    type: string;
-    selector: string;
-};
-export declare type ScreenshotSettings = {
-    name?: string;
-    screenshotMode?: 'FULL_RESIZE' | 'FULL_SCROLL' | 'VIEWPORT' | 'FULL_REGION';
-    scrollRootElement?: CommonSelector;
-    selectorsToFindRegionsFor?: Array<CommonSelector>;
-    hideCaret?: boolean;
-    waitBeforeCapture?: number;
-    overlap?: {
-        top: number;
-        bottom: number;
-    };
-};
-export declare type SnapshotSettings = {
-    name?: string;
-    deviceList?: any;
-    resourceSeparation?: boolean;
-    waitBeforeCapture?: number;
-};
-export interface BrokerRequest {
-    protocolVersion: '1.0';
-    name: 'TAKE_SCREENSHOT' | 'TAKE_SNAPSHOT';
-    key: string;
-    payload: ScreenshotSettings | SnapshotSettings;
-}
-export declare function broker(url: string, request: BrokerRequest, options?: any): Promise<any>;
-export {};