ff-automationv2 2.2.2 → 2.2.6

package/dist/automation/mobileSession/initiateMobileSession.js

@@ -1,10 +1,14 @@
 import { remote } from "webdriverio";
 import { execSync } from "child_process";
+import { logger } from "../../utils/logger/logData.js";
+import { CloudSession } from "../cloudSession/initiateCloudSession.js";
 export class MobileSession {
-    constructor(appiumPort) {
-        this.browser = null;
+    constructor(appiumPort, isCloud, capabilities, CloudConfig) {
+        this.driver = null;
         this.currentAppPackage = "";
         this.appiumPort = appiumPort;
+        this.isCloud = isCloud;
+        this.cloudSessionInstances = new CloudSession(capabilities, CloudConfig);
     }
     async openApp(arg) {
         try {
@@ -22,26 +26,47 @@ export class MobileSession {
         }
     }
     async open(arg) {
-        this.browser = await this.openApp({ capabilities: arg.capabilities });
         const appPackage = arg.keywords[0];
         const appActivity = arg.keywords[1];
         this.currentAppPackage = appPackage;
-        // arg.capabilities["appium:appPackage"] = appPackage;
-        // arg.capabilities["appium:appActivity"] = appActivity;
-        execSync(`adb -s ${arg.capabilities["appium:udid"]} shell pm clear ${appPackage}`).toString();
-        execSync(`adb -s ${arg.capabilities["appium:udid"]} shell am start -n ${appPackage}/${appActivity}`).toString();
+        try {
+            const response = await fetch(`http://127.0.0.1:${this.appiumPort}/wd/hub/status`);
+            if (response.status !== 200) {
+                throw new Error("Appium server is not running.");
+            }
+        }
+        catch (error) {
+            throw new Error("Appium server is not running or unreachable.", { cause: error });
+        }
+        try {
+            await execSync(`adb -s ${arg.capabilities["appium:udid"]} shell pm clear ${appPackage}`).toString();
+            await execSync(`adb -s ${arg.capabilities["appium:udid"]} shell am start -n ${appPackage}/${appActivity}`).toString();
+        }
+        catch (error) {
+            const output = error.stderr?.toString() || error.message || "";
+            if (output.toLowerCase().includes("device") && output.toLowerCase().includes("not found")) {
+                throw new Error(`Device '${arg.capabilities["appium:udid"]}' not found or offline.`, { cause: error });
+            }
+            if (output.includes("Error type 3") || output.includes("does not exist") || output.includes("Failed")) {
+                throw new Error(`App not found or invalid activity: ${appPackage}/${appActivity} is not installed on the device`, { cause: error });
+            }
+            throw new Error(`ADB execution failed: ${output}`, { cause: error });
+        }
+        this.driver = this.isCloud
+            ? await this.cloudSessionInstances.initialize() : await this.openApp({ capabilities: arg.capabilities });
+        logger.info(`Application launched`);
     }
     async close() {
-        if (this.browser) {
+        if (this.driver) {
             const apppackage = this.currentAppPackage;
-            await this.browser.terminateApp(apppackage, []);
-            this.browser = null;
+            await this.driver.terminateApp(apppackage);
+            this.driver = null;
         }
     }
     async getCurrentDriver() {
-        if (!this.browser) {
+        if (!this.driver) {
             throw new Error("Browser is not initialized");
         }
-        return this.browser;
+        return this.driver;
     }
 }

package/dist/core/constants/allAction.js

@@ -16,5 +16,6 @@ export const allKeywordAction = [
     "closeApp",
     "switch",
     "cleartext",
-    "tap"
+    "tap",
+    "combined"
 ];

package/dist/core/constants/defaultValues.d.ts

@@ -1 +1 @@
-export declare const DEFAULT_PAGE_LOAD = 2000;
+export declare const DEFAULT_PAGE_LOAD = 10000;

package/dist/core/constants/defaultValues.js

@@ -1 +1 @@
-export const DEFAULT_PAGE_LOAD = 2000;
+export const DEFAULT_PAGE_LOAD = 10000;

package/dist/core/constants/supportedActions.js

@@ -28,5 +28,72 @@ export const ELEMENTLESS_ACTION = [
     "PressAnyKeyNTimes",
     "SetClipBoardText",
     "PressAnyKey",
-    "PressEnterKey"
+    "PressEnterKey",
+    "SwitchToNewWindowIfUrlContainsString",
+    "MOB_OpenNotification",
+    "MOB_ResetApp",
+    "MOB_HideKeyboard",
+    "MOB_SetEmulatorPowerStateOff",
+    "MOB_OpenChromeBrowser",
+    "MOB_SetDeviceOrientationAsPortrait",
+    "MOB_SetDeviceOrientationAsLandscape",
+    "MOB_SetEmulatorPowerStateOn",
+    "MOB_AirplaneModeSwitchOn",
+    "MOB_LockDevice",
+    "MOB_WifiSwitchOff",
+    "MOB_WifiSwitchOn",
+    "Continue",
+    "MOB_GpsSwitchOn",
+    "MOB_GpsSwitchOff",
+    "MOB_RestartCurrentDevice",
+    "MOB_AirplaneModeSwitchOff",
+    "Break",
+    "MOB_TapOnSpecifiedLocation",
+    "MOB_PressHomeKey",
+    "MOB_OpenMobileApplication",
+    "MOB_IsAppInstalled",
+    "MOB_ReceiveMessageOnEmulator",
+    "MOB_UninstallAPK",
+    "MOB_InstallAPK",
+    "MOB_TerminateAppUsingAppPackage",
+    "MOB_OpenAppWithApkFilePath",
+    "MOB_ActivateAppUsingAppPackage",
+    "VerifyLighthouseScore",
+    "VerifyAccessibilityScore",
+    "VerifyBrowserWindowYLocation",
+    "VerifyBrowserWindowXLocation",
+    "VerifyBrowserWindowWidth",
+    "VerifyBrowserWindowUrlIsString",
+    "VerifyBrowserWindowUrlContainsExpectedUrl",
+    "VerifyBrowserWindowTitleIsString",
+    "VerifyBrowserWindowTitleContainsString",
+    "VerifyBrowserWindowHeight",
+    "VerifyBrowserHtmlCodeContainsString",
+    "VerifyBestPracticesScore",
+    "VerifyAllBrokenImages",
+    "VerifyIfCookieNameIsDeleted",
+    "VerifyIfCookieNameIsAdded",
+    "VerifyIfBrowserWindowIsClosed",
+    "VerifyIfAllCookiesAreDeleted",
+    "VerifyIfCookieObjectIsPresent",
+    "VerifyIfImageIsBroken",
+    "VerifyIfLinkIsBroken",
+    "VerifyIfLinkIsWorking",
+    "VerifyIfLinksAreBroken",
+    "VerifyIfLinksAreWorking",
+    "VerifyIfStatusCodeOfALinkIsStatusCode",
+    "VerifyIfStatusCodesOfLinks",
+    "VerifyLinkNavigatesToTitle",
+    "VerifyNavigateURL",
+    "VerifyNumberOfElementsByTagName",
+    "VerifyNumberOfElementsByXpath",
+    "VerifyPartialTitleOfCurrentPage",
+    "VerifyPerformanceScore",
+    "VerifyPwaScore",
+    "VerifySeoScore",
+    "VerifyTitleInAllPage",
+    "VerifyTitleOfCurrentPage",
+    "VerifyAllBrowserWindowsClosed",
+    "VerifyHexCodeForGivenXYCoordinates",
+    "VerifyIfXAndYCoordinateOfElement"
 ];

package/dist/core/interfaces/actionInterface.d.ts

@@ -228,6 +228,35 @@ export interface IActionExecutor {
     getAudioHeight(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void>;
     getAudioDimension(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void>;
     getAudioDecodedByte(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void>;
+    OpenNotification(): Promise<void>;
+    ResetApp(): Promise<void>;
+    HideKeyboard(): Promise<void>;
+    SetEmulatorPowerStateOff(): Promise<void>;
+    OpenChromeBrowser(): Promise<void>;
+    SetDeviceOrientationAsPortrait(): Promise<void>;
+    SetDeviceOrientationAsLandscape(): Promise<void>;
+    SetEmulatorPowerStateOn(): Promise<void>;
+    AirplaneModeSwitchOn(): Promise<void>;
+    LockDevice(): Promise<void>;
+    WifiSwitchOff(): Promise<void>;
+    WifiSwitchOn(): Promise<void>;
+    Continue(): Promise<void>;
+    GpsSwitchOn(): Promise<void>;
+    GpsSwitchOff(): Promise<void>;
+    RestartCurrentDevice(): Promise<void>;
+    AirplaneModeSwitchOff(): Promise<void>;
+    Break(): Promise<void>;
+    PressHomeKey(): Promise<void>;
+    TapOnSpecifiedLocation(value: string): Promise<void>;
+    OpenMobileApplication(value: string): Promise<void>;
+    IsAppInstalled(value: string): Promise<void>;
+    ReceiveMessageOnEmulator(value: string): Promise<void>;
+    UninstallAPK(value: string): Promise<void>;
+    InstallAPK(value: string): Promise<void>;
+    TerminateAppUsingAppPackage(value: string): Promise<void>;
+    OpenAppWithApkFilePath(value: string): Promise<void>;
+    ActivateAppUsingAppPackage(value: string): Promise<void>;
+    LongPress(selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void>;
     MOB_PressBackKey(): Promise<void>;
     WaitTillPresenceOfElement(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void>;
     WaitTillPresenceOfAllElements(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void>;

package/dist/core/interfaces/browserCapabilitiesInterface.d.ts

@@ -1,3 +1,20 @@
-export interface browserCapabilities {
+type Browser = 'chrome' | 'firefox' | 'edge' | 'safari';
+export declare function getCapabilities(browserName: Browser): {
+    'goog:chromeOptions'?: {
+        args: string[];
+    } | undefined;
     browserName: string;
-}
+} | {
+    'moz:firefoxOptions'?: {
+        args: string[];
+    } | undefined;
+    browserName: string;
+} | {
+    'ms:edgeOptions'?: {
+        args: string[];
+    } | undefined;
+    browserName: string;
+} | {
+    browserName: string;
+};
+export {};

package/dist/core/interfaces/browserCapabilitiesInterface.js

@@ -1 +1,33 @@
-export {};
+export function getCapabilities(browserName) {
+    const isLinux = process.platform === 'linux';
+    const browserCapabilities = {
+        chrome: {
+            browserName: 'chrome',
+            ...(isLinux && {
+                'goog:chromeOptions': {
+                    args: ['--ozone-platform=x11']
+                }
+            })
+        },
+        firefox: {
+            browserName: 'firefox',
+            ...(isLinux && {
+                'moz:firefoxOptions': {
+                    args: ['-headless']
+                }
+            })
+        },
+        edge: {
+            browserName: 'MicrosoftEdge',
+            ...(isLinux && {
+                'ms:edgeOptions': {
+                    args: ['--ozone-platform=x11']
+                }
+            })
+        },
+        safari: {
+            browserName: 'safari'
+        }
+    };
+    return browserCapabilities[browserName];
+}

package/dist/core/interfaces/browserConfigurationInterface.d.ts

@@ -1,3 +1,4 @@
+import { Browser } from "../../core/types/browserType";
 export interface BrowserConfig {
-    browserName: string;
+    browserName: Browser;
 }

package/dist/core/interfaces/cloudConfigInterface.d.ts

@@ -0,0 +1,9 @@
+import { Protocol } from "../types/cloudprotocolType";
+export interface CloudConfig {
+    protocol?: Protocol;
+    hostname?: string;
+    projectName?: string;
+    licenseId?: string;
+    accessKey?: string;
+    path?: string;
+}

package/dist/core/interfaces/cloudConfigInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/executionDetails.d.ts

@@ -1,4 +1,5 @@
 import { BrowserConfig } from "./browserConfigurationInterface.js";
+import { CloudConfig } from "./cloudConfigInterface.js";
 import { platform } from "../types/scriptTypesType.js";
 import { Producer } from "kafkajs";
 export interface AutomationRequest {
@@ -27,6 +28,9 @@ export interface AutomationRequest {
     token: string;
     appiumPort: number;
     realDeviceId: string;
-    platform_version: string;
-    kafkaProducerInstance: Producer;
+    platformVersion: string;
+    kafkaProducerInstance: Producer | any;
+    isCloud?: boolean;
+    capabilities?: Record<string, any>;
+    cloudConfig?: CloudConfig;
 }

package/dist/core/interfaces/fireflinkScriptPayloadInterface.d.ts

@@ -27,7 +27,7 @@ export interface IPayload {
 export interface IFireFlinkApiService {
     getInstancesDetailsApi(headers: Record<string, string>, url: string): Promise<any>;
 }
-export interface IScriptRunner {
+export interface IFireflinkService {
     runGetInstancesDetails(projectId: string, token: string, serverHost: string): Promise<any>;
 }
 export interface IKafkaPayload {

package/dist/core/main/actionHandlerFactory.js

@@ -38,7 +38,7 @@ export function createActionHandlers(context) {
                 await context.androidSession.open({
                     capabilities: {
                         platformName: "Android",
-                        "appium:platformVersion": context.request.platform_version,
+                        "appium:platformVersion": context.request.platformVersion,
                         "appium:deviceName": "AndroidDevice",
                         "appium:udid": context.request.realDeviceId,
                         "appium:automationName": "UiAutomator2",
@@ -506,6 +506,183 @@ export function createActionHandlers(context) {
         GetSize: withExecutor(async (executor, result) => {
             await executor.getSize(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
         }),
+        VerifyAttributeValue: withExecutor(async (executor, result) => {
+            await executor.VerifyAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyPartialAttributeValue: withExecutor(async (executor, result) => {
+            await executor.VerifyPartialAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyTagName: withExecutor(async (executor, result) => {
+            await executor.VerifyTagName(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyTitleOfCurrentPage: withExecutor(async (executor, result) => {
+            await executor.VerifyTitleOfCurrentPage(result.value);
+        }),
+        VerifyPartialTitleOfCurrentPage: withExecutor(async (executor, result) => {
+            await executor.VerifyPartialTitleOfCurrentPage(result.value);
+        }),
+        VerifyNavigateURL: withExecutor(async (executor, result) => {
+            await executor.VerifyNavigateURL(result.value);
+        }),
+        VerifyValueOfElementIsString: withExecutor(async (executor, result) => {
+            await executor.VerifyValueOfElementIsString(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyValueOfElementContainsString: withExecutor(async (executor, result) => {
+            await executor.VerifyValueOfElementContainsString(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyValueOfElementIsCleared: withExecutor(async (executor, result) => {
+            await executor.VerifyValueOfElementIsCleared(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyXLocationOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyXLocationOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyYLocationOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyYLocationOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyHeightOfWebElement: withExecutor(async (executor, result) => {
+            await executor.VerifyHeightOfWebElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyWidthOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyWidthOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyRadioButtonIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyRadioButtonIsSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyRadioButtonIsNotSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyRadioButtonIsNotSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyBrowserWindowWidth: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowWidth(result.value);
+        }),
+        VerifyBrowserWindowHeight: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowHeight(result.value);
+        }),
+        VerifyBrowserWindowXLocation: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowXLocation(result.value);
+        }),
+        VerifyBrowserWindowYLocation: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowYLocation(result.value);
+        }),
+        VerifyBrowserHtmlCodeContainsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserHtmlCodeContainsString(result.value);
+        }),
+        VerifyIfCookieNameIsAdded: withExecutor(async (executor, result) => {
+            await executor.VerifyIfCookieNameIsAdded(result.value);
+        }),
+        VerifyIfCookieNameIsDeleted: withExecutor(async (executor, result) => {
+            await executor.VerifyIfCookieNameIsDeleted(result.value);
+        }),
+        VerifyIfLinkIsBroken: withExecutor(async (executor, result) => {
+            await executor.VerifyIfLinkIsBroken(result.value);
+        }),
+        VerifyCssAttributeValue: withExecutor(async (executor, result) => {
+            await executor.VerifyCssAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoIsPlaying: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoIsPlaying(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyNumberOfElementsByTagName: withExecutor(async (executor, result) => {
+            await executor.VerifyNumberOfElementsByTagName(result.value);
+        }),
+        VerifyNumberOfElementsByXpath: withExecutor(async (executor, result) => {
+            await executor.VerifyNumberOfElementsByXpath(result.value);
+        }),
+        VerifyListBoxOptionsAreSorted: withExecutor(async (executor, result) => {
+            await executor.VerifyListBoxOptionsAreSorted(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithIndexIsSelectedInListBox: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithIndexIsSelectedInListBox(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithIndexIsDeselectedInElement: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithIndexIsDeselectedInElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyAllOptionsAreSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyAllOptionsAreSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyAllOptionsAreDeselected: withExecutor(async (executor, result) => {
+            await executor.VerifyAllOptionsAreDeselected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithValueIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithValueIsSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfOptionWithValueIsDeselected: withExecutor(async (executor, result) => {
+            await executor.VerifyIfOptionWithValueIsDeselected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfSpecifiedOptionIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyIfSpecifiedOptionIsSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyThatSpecifiedOptionIsNotSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyThatSpecifiedOptionIsNotSelected(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfGivenOptionIsDuplicate: withExecutor(async (executor, result) => {
+            await executor.VerifyIfGivenOptionIsDuplicate(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyTitleInAllPage: withExecutor(async (executor, result) => {
+            await executor.VerifyTitleInAllPage(result.value);
+        }),
+        VerifyLinkNavigatesToTitle: withExecutor(async (executor, result) => {
+            await executor.VerifyLinkNavigatesToTitle(result.value);
+        }),
+        VerifyBrowserWindowTitleContainsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowTitleContainsString(result.value);
+        }),
+        VerifyBrowserWindowUrlIsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowUrlIsString(result.value);
+        }),
+        VerifyBrowserWindowUrlContainsExpectedUrl: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowUrlContainsExpectedUrl(result.value);
+        }),
+        VerifyCheckBoxIsNotSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyCheckBoxIsNotSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyCheckBoxIsSelected: withExecutor(async (executor, result) => {
+            await executor.VerifyCheckBoxIsSelected(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyBrowserWindowTitleIsString: withExecutor(async (executor, result) => {
+            await executor.VerifyBrowserWindowTitleIsString(result.value);
+        }),
+        VerifyIfBrowserWindowIsClosed: withExecutor(async (executor) => {
+            await executor.VerifyIfBrowserWindowIsClosed();
+        }),
+        VerifyAllBrowserWindowsClosed: withExecutor(async (executor) => {
+            await executor.VerifyAllBrowserWindowsClosed();
+        }),
+        VerifyIfAllCookiesAreDeleted: withExecutor(async (executor) => {
+            await executor.VerifyIfAllCookiesAreDeleted();
+        }),
+        VerifyIfCookieObjectIsPresent: withExecutor(async (executor, result) => {
+            await executor.VerifyIfCookieObjectIsPresent(result.value);
+        }),
+        VerifyIfXAndYCoordinateOfElement: withExecutor(async (executor, result) => {
+            await executor.VerifyIfXAndYCoordinateOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoIsMuted: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoIsMuted(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoIsPaused: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoIsPaused(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoEnded: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoEnded(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoPlayingInMute: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoPlayingInMute(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfVideoPlayingInUnmute: withExecutor(async (executor, result) => {
+            await executor.VerifyIfVideoPlayingInUnmute(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioIsPlaying: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioIsPlaying(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioIsPaused: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioIsPaused(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioIsMuted: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioIsMuted(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
+        VerifyIfAudioEnded: withExecutor(async (executor, result) => {
+            await executor.VerifyIfAudioEnded(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        }),
         VerifyIfLinkIsWorking: withExecutor(async (executor, result) => {
             await executor.VerifyIfLinkIsWorking(result.value);
         }),
@@ -637,26 +814,95 @@ export function createActionHandlers(context) {
         GetAudioDecodedByte: withExecutor(async (executor, result) => {
             await executor.getAudioDecodedByte(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
         }),
-        VerifyXLocationOfElement: withExecutor(async (executor, result) => {
-            await executor.VerifyXLocationOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_OpenNotification: withExecutor(async (executor) => {
+            await executor.OpenNotification();
         }),
-        VerifyYLocationOfElement: withExecutor(async (executor, result) => {
-            await executor.VerifyYLocationOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_PressEnterKey: withExecutor(async (executor) => {
+            await executor.PressEnterKey();
         }),
-        VerifyWidthOfElement: withExecutor(async (executor, result) => {
-            await executor.VerifyWidthOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_ResetApp: withExecutor(async (executor) => {
+            await executor.ResetApp();
         }),
-        VerifyIfXAndYCoordinateOfElement: withExecutor(async (executor, result) => {
-            await executor.VerifyIfXAndYCoordinateOfElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_HideKeyboard: withExecutor(async (executor) => {
+            await executor.HideKeyboard();
         }),
-        VerifyPartialAttributeValue: withExecutor(async (executor, result) => {
-            await executor.VerifyPartialAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_SetEmulatorPowerStateOff: withExecutor(async (executor) => {
+            await executor.SetEmulatorPowerStateOff();
         }),
-        VerifyAttributeValue: withExecutor(async (executor, result) => {
-            await executor.VerifyAttributeValue(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_OpenChromeBrowser: withExecutor(async (executor) => {
+            await executor.OpenChromeBrowser();
         }),
-        VerifyHeightOfWebElement: withExecutor(async (executor, result) => {
-            await executor.VerifyHeightOfWebElement(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_SetDeviceOrientationAsPortrait: withExecutor(async (executor) => {
+            await executor.SetDeviceOrientationAsPortrait();
+        }),
+        MOB_SetDeviceOrientationAsLandscape: withExecutor(async (executor) => {
+            await executor.SetDeviceOrientationAsLandscape();
+        }),
+        MOB_SetEmulatorPowerStateOn: withExecutor(async (executor) => {
+            await executor.SetEmulatorPowerStateOn();
+        }),
+        MOB_AirplaneModeSwitchOn: withExecutor(async (executor) => {
+            await executor.AirplaneModeSwitchOn();
+        }),
+        MOB_LockDevice: withExecutor(async (executor) => {
+            await executor.LockDevice();
+        }),
+        MOB_WifiSwitchOff: withExecutor(async (executor) => {
+            await executor.WifiSwitchOff();
+        }),
+        MOB_WifiSwitchOn: withExecutor(async (executor) => {
+            await executor.WifiSwitchOn();
+        }),
+        Continue: withExecutor(async (executor) => {
+            await executor.Continue();
+        }),
+        MOB_GpsSwitchOn: withExecutor(async (executor) => {
+            await executor.GpsSwitchOn();
+        }),
+        MOB_GpsSwitchOff: withExecutor(async (executor) => {
+            await executor.GpsSwitchOff();
+        }),
+        MOB_RestartCurrentDevice: withExecutor(async (executor) => {
+            await executor.RestartCurrentDevice();
+        }),
+        MOB_AirplaneModeSwitchOff: withExecutor(async (executor) => {
+            await executor.AirplaneModeSwitchOff();
+        }),
+        Break: withExecutor(async (executor) => {
+            await executor.Break();
+        }),
+        MOB_PressHomeKey: withExecutor(async (executor) => {
+            await executor.PressHomeKey();
+        }),
+        MOB_TapOnSpecifiedLocation: withExecutor(async (executor, result) => {
+            await executor.TapOnSpecifiedLocation(result.value);
+        }),
+        MOB_OpenMobileApplication: withExecutor(async (executor, result) => {
+            await executor.OpenMobileApplication(result.value);
+        }),
+        MOB_IsAppInstalled: withExecutor(async (executor, result) => {
+            await executor.IsAppInstalled(result.value);
+        }),
+        MOB_ReceiveMessageOnEmulator: withExecutor(async (executor, result) => {
+            await executor.ReceiveMessageOnEmulator(result.value);
+        }),
+        MOB_UninstallAPK: withExecutor(async (executor, result) => {
+            await executor.UninstallAPK(result.value);
+        }),
+        MOB_InstallAPK: withExecutor(async (executor, result) => {
+            await executor.InstallAPK(result.value);
+        }),
+        MOB_TerminateAppUsingAppPackage: withExecutor(async (executor, result) => {
+            await executor.TerminateAppUsingAppPackage(result.value);
+        }),
+        MOB_OpenAppWithApkFilePath: withExecutor(async (executor, result) => {
+            await executor.OpenAppWithApkFilePath(result.value);
+        }),
+        MOB_ActivateAppUsingAppPackage: withExecutor(async (executor, result) => {
+            await executor.ActivateAppUsingAppPackage(result.value);
+        }),
+        MOB_LongPress: withExecutor(async (executor, result) => {
+            await executor.LongPress(result.selector, result.value, result.elementName, result.elementType);
         }),
         MOB_PressBackKey: withExecutor(async (executor) => {
             await executor.MOB_PressBackKey();

package/dist/core/main/executionContext.js

@@ -7,9 +7,9 @@ export class ExecutionContext {
     constructor(request) {
         this.request = request;
         this.executor = null;
-        this.session = new BrowserSession(request.browser.browserName, DEFAULT_PAGE_LOAD);
+        this.session = new BrowserSession(request.browser.browserName, request.isCloud, request.capabilities, DEFAULT_PAGE_LOAD, request.cloudConfig);
         this.locator = new ElementGetter();
-        this.scriptAppender = new ScriptDataAppender();
-        this.androidSession = new MobileSession(request.appiumPort);
+        this.scriptAppender = new ScriptDataAppender(request.isCloud);
+        this.androidSession = new MobileSession(request.appiumPort, request.isCloud, request.capabilities, request.cloudConfig);
     }
 }