@24i/bigscreen-sdk 0.9.9-alpha.2149 → 0.9.9-alpha.2151

package/__mocks__/@24i/bigscreen-sdk/animations.ts

@@ -0,0 +1,2 @@
+export { AnimationUtils } from '@24i/bigscreen-sdk/animations';
+export { JSAnimations } from '@24i/bigscreen-sdk/animations/mock';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@24i/bigscreen-sdk",
-    "version": "0.9.9-alpha.2149",
+    "version": "0.9.9-alpha.2151",
     "description": "SmartApps BIGscreen SDK monorepo",
     "main": "index.js",
     "scripts": {
@@ -188,6 +188,7 @@
         "./list/interface": "./packages/list/src/interface.ts",
         "./list/utils": "./packages/list/utils/index.ts",
         "./logger/ConsoleLogger": "./packages/logger/src/loggers/ConsoleLogger/index.ts",
+        "./logger/SentryLogger/mock": "./packages/logger/src/loggers/SentryLogger/mock.ts",
         "./logger/SentryLogger": "./packages/logger/src/loggers/SentryLogger/index.ts",
         "./logger": "./packages/logger/src/index.ts",
         "./lottie-animations": "./packages/lottie-animations/src/index.ts",

package/packages/animations/src/__mocks__/JSAnimations.ts

@@ -0,0 +1,30 @@
+export class JSAnimations {
+    animationRunning = false;
+
+    from = 0;
+
+    to = 0;
+
+    frameCallback?: (value: number) => void;
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    start(from: number, to: number, time: number, easingFunction: any): JSAnimations {
+        this.to = to;
+        this.animationRunning = true;
+        this.frameCallback = undefined;
+        setTimeout(this.frame, 0);
+        return this;
+    }
+
+    frame = (): void => {
+        if (this.frameCallback) {
+            this.frameCallback(this.to);
+        }
+    };
+
+    onFrame(callback: (value: number) => void) {
+        if (typeof callback === 'function') {
+            this.frameCallback = callback;
+        }
+    }
+}

package/packages/conviva/src/__mocks__/ConvivaMock.ts

@@ -0,0 +1,36 @@
+import type { ConvivaSDK } from '../ConvivaSDK';
+
+export const ConvivaMock: ConvivaSDK = {
+    Constants: {
+        StreamType: {
+            LIVE: 'LIVE',
+            VOD: 'VOD',
+        },
+        LogLevel: {
+            DEBUG: 0,
+            INFO: 1,
+            WARNING: 2,
+            ERROR: 3,
+            NONE: 4,
+        },
+        DeviceMetadata: {
+            MANUFACTURER: 'MANUFACTURER',
+            MODEL: 'MODEL',
+            TYPE: 'TYPE',
+        },
+        DeviceType: {
+            SMARTTV: 'SMARTTV',
+        },
+        ASSET_NAME: 'ASSET_NAME',
+        CUSTOMER_KEY: 'CUSTOMER_KEY',
+        DEFAULT_RESOURCE: 'DEFAULT_RESOURCE',
+        DURATION: 'DURATION',
+        ENCODED_FRAMERATE: 'ENCODED_FRAMERATE',
+        GATEWAY_URL: 'GATEWAY_URL',
+        IS_LIVE: 'IS_LIVE',
+        LOG_LEVEL: 'LOG_LEVEL',
+        PLAYER_NAME: 'PLAYER_NAME',
+        STREAM_URL: 'STREAM_URL',
+        VIEWER_ID: 'VIEWER_ID',
+    },
+};

package/packages/developer-tools/src/TechnicalInfo/__mocks__/Device.ts

@@ -0,0 +1,51 @@
+class Device {
+    async getUuid() {
+        return 'uuidXYZ';
+    }
+
+    async getManufacturerName() {
+        return 'manufacturer name';
+    }
+
+    async getPlatformName() {
+        return 'platform name';
+    }
+
+    async getPlatformVersion() {
+        return 'platform version';
+    }
+
+    async getDeviceName() {
+        return 'device name';
+    }
+
+    async getModelName() {
+        return 'model name';
+    }
+
+    async getFirmware() {
+        return 'device firmware';
+    }
+
+    async is4KSupported() {
+        return true;
+    }
+
+    async is8KSupported() {
+        return false;
+    }
+
+    async getLocalIP() {
+        return 'local ip';
+    }
+
+    async getConnectionType() {
+        return 'connection type';
+    }
+
+    async getMacAddress() {
+        return 'mac address';
+    }
+}
+
+export { Device };

package/packages/developer-tools/src/TechnicalInfo/__mocks__/Player.ts

@@ -0,0 +1,7 @@
+class Player {
+    static playerName = 'PlayerEngine';
+
+    static version = 'v1.0.0';
+}
+
+export { Player };

package/packages/developer-tools/src/TechnicalInfo/__mocks__/Storage.ts

@@ -0,0 +1,9 @@
+/* eslint-disable no-magic-numbers */
+
+class Storage {
+    async getUsedSize() {
+        return 2048; // 2 kB
+    }
+}
+
+export { Storage };

package/packages/driver-base/src/__mocks__/DeviceBase.ts

@@ -0,0 +1,100 @@
+import { DeviceBase as AbstractDeviceBase } from '../DeviceBase';
+import { ScreenSaverStatus } from '../types/ScreenSaverStatus';
+import { ConnectionType } from '../ConnectionType';
+
+export class DeviceBase extends AbstractDeviceBase {
+    volume = 0;
+
+    isMuted = false;
+
+    screenSaverStatus = { enabled: false };
+
+    async initDevice() {
+        return undefined;
+    }
+
+    exit() {}
+
+    reboot() {}
+
+    async getManufacturerName() {
+        return 'manufacturer name';
+    }
+
+    async getPlatformName() {
+        return 'platform name';
+    }
+
+    async getPlatformVersion() {
+        return 'platform version';
+    }
+
+    async getDeviceName() {
+        return 'device name';
+    }
+
+    async getModelName() {
+        return 'model name';
+    }
+
+    async getFirmware() {
+        return 'device firmware';
+    }
+
+    async is4KSupported() {
+        return true;
+    }
+
+    async is8KSupported() {
+        return false;
+    }
+
+    async getUuid() {
+        return this.getBaseUuid();
+    }
+
+    async getVolume() {
+        return this.volume;
+    }
+
+    async setVolume(volumePercentage: number) {
+        this.volume = volumePercentage;
+    }
+
+    async mute(mute: boolean) {
+        this.isMuted = mute;
+    }
+
+    async isMute() {
+        return this.isMuted;
+    }
+
+    async getScreenSaver() {
+        return this.screenSaverStatus;
+    }
+
+    async setScreenSaver(status: ScreenSaverStatus) {
+        this.screenSaverStatus.enabled = status.enabled;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string) {
+        return false;
+    }
+
+    async isNetworkConnected() {
+        return true;
+    }
+
+    async getConnectionType() {
+        return 'unknown' as ConnectionType;
+    }
+
+    async getLocalIP() {
+        return '1.2.3.4';
+    }
+
+    async getMacAddress() {
+        return '00:11:22:33:44:55';
+    }
+}

package/packages/driver-base/src/__mocks__/keyMap.ts

@@ -0,0 +1,41 @@
+export const KEYMAP = {
+    LEFT: 37,
+    RIGHT: 39,
+    UP: 38,
+    DOWN: 40,
+    BACK: 8,
+    ENTER: 13,
+    ESC: 27,
+    PLAY: 415,
+    PAUSE: 19,
+    PLAYPAUSE: 1000,
+    STOP: 413,
+    FF: 417,
+    REW: 412,
+    RED: 82,
+    GREEN: 71,
+    YELLOW: 89,
+    BLUE: 66,
+    NUM_0: 48,
+    NUM_1: 49,
+    NUM_2: 50,
+    NUM_3: 51,
+    NUM_4: 52,
+    NUM_5: 53,
+    NUM_6: 54,
+    NUM_7: 55,
+    NUM_8: 56,
+    NUM_9: 57,
+    KP_0: 96,
+    KP_1: 97,
+    KP_2: 98,
+    KP_3: 99,
+    KP_4: 100,
+    KP_5: 101,
+    KP_6: 102,
+    KP_7: 103,
+    KP_8: 104,
+    KP_9: 105,
+    CHANNEL_UP: 33,
+    CHANNEL_DOWN: 34,
+};

package/packages/driver-entone/src/__mocks__/entone.ts

@@ -0,0 +1,177 @@
+/* eslint-disable no-magic-numbers */
+import { INetworkCallback, NetworkEvent, UserAgentMode } from '../IEntone';
+
+/**
+ * Internal mock state
+ */
+export const entoneState = {
+    volumePercentage: 100,
+    isMuted: false,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    networkEventCallback: (event: NetworkEvent, param?: any) => {},
+    dispatchEventNetworkLinkDown: () => {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        const { NETWORK_LINK_STATUS_DOWN } = ENTONE.network;
+        entoneState.networkEventCallback({ status: NETWORK_LINK_STATUS_DOWN });
+    },
+    dispatchEventNetworkLinkUp: () => {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        const { NETWORK_LINK_STATUS_UP } = ENTONE.network;
+        entoneState.networkEventCallback({ status: NETWORK_LINK_STATUS_UP });
+    },
+};
+
+/**
+ * Mocking Entone API module.
+ * Note: Constant values were grabbed from Kamai 500
+ */
+export const ENTONE = {
+    status: {
+        ACCESS_DENIED: 'ENTONE.status.ACCESS_DENIED',
+        ALREADY_EXIST: 'ENTONE.status.ALREADY_EXIST',
+        DIR_NOT_EMPTY: 'ENTONE.status.DIR_NOT_EMPTY',
+        ERROR: 'ENTONE.status.ERROR',
+        INVALID_ARGUMENT: 'ENTONE.status.INVALID_ARGUMENT',
+        NOT_EXIST: 'ENTONE.status.NOT_EXIST',
+        NOT_IMPLEMENTED: 'ENTONE.status.NOT_IMPLEMENTED',
+        NOT_PERMITTED: 'ENTONE.status.NOT_PERMITTED',
+        NOT_READY: 'ENTONE.status.NOT_READY',
+        RESOURCE_BUSY: 'ENTONE.status.RESOURCE_BUSY',
+        SUCCESS: 'ENTONE.status.SUCCESS',
+        TIMED_OUT: 'ENTONE.status.TIMED_OUT',
+    },
+    input: {
+        KEY_0: 48,
+        KEY_1: 49,
+        KEY_2: 50,
+        KEY_3: 51,
+        KEY_4: 52,
+        KEY_5: 53,
+        KEY_6: 54,
+        KEY_7: 55,
+        KEY_8: 56,
+        KEY_9: 57,
+        KEY_AUDIO: 57469,
+        KEY_BACK: 8,
+        KEY_BLUE: 57508,
+        KEY_CHANNELDOWN: 57510,
+        KEY_CHANNELUP: 57509,
+        KEY_CLOSED_CAPTION: 57545,
+        KEY_DISPLAY: 57459,
+        KEY_DOWN: 40,
+        KEY_ENTER: 13,
+        KEY_EXIT: 27,
+        KEY_FASTFORWARD: 57529,
+        KEY_FAVORITES: 57465,
+        KEY_GREEN: 57506,
+        KEY_GUIDE: 58744,
+        KEY_INFO: 57459,
+        KEY_INPUT: 58745,
+        KEY_LANG: 57469,
+        KEY_LAST: 57514,
+        KEY_LEFT: 37,
+        KEY_LIST: 57500,
+        KEY_MENU: 57457,
+        KEY_MUSIC: 57398,
+        KEY_MUTE: 57517,
+        KEY_NEXTCHAPTER: 57531,
+        KEY_OPTIONS: 57456,
+        KEY_PAUSE: 57519,
+        KEY_PLAY: 57520,
+        KEY_PLAYPAUSE: 57519,
+        KEY_POWER: 57454,
+        KEY_PREVIOUSCHAPTER: 57530,
+        KEY_PVR: 57400,
+        KEY_RECORD: 57525,
+        KEY_RED: 57505,
+        KEY_REWIND: 57528,
+        KEY_RIGHT: 39,
+        KEY_STOP: 57521,
+        KEY_TELETEXT: 57544,
+        KEY_TV: 57478,
+        KEY_UP: 38,
+        KEY_VOD: 57397,
+        KEY_VOLUMEDOWN: 57516,
+        KEY_VOLUMEUP: 57515,
+        KEY_YELLOW: 57507,
+    },
+    network: {
+        EVENT_WIFI_LIST_UPDATED: 'wifi_list_updated',
+        NETWORK_LINK_STATUS_DOWN: 28676,
+        NETWORK_LINK_STATUS_ETH_DOWN: 28678,
+        NETWORK_LINK_STATUS_ETH_UP: 28677,
+        NETWORK_LINK_STATUS_UP: 28675,
+        NETWORK_READY: 28674,
+        nic_type: {
+            CAT5: 1,
+            HPNA: 2,
+            WIFI: 4,
+            MOCA: 8,
+            VIF: 16,
+        },
+        getConfig: () => ({
+            status: ENTONE.status.SUCCESS,
+            result: {
+                acs_last_contacted: 1618358446,
+                auto_cfg_flags: 1,
+                current_active_wan: 'eth0',
+                dhcp_last_contacted: 1618309092,
+                dns_1st: '8.8.8.8',
+                dns_2nd: '8.8.4.4',
+                gateway: '172.16.15.254',
+                hostname: '26-38746151',
+                network: [{
+                    ip_address: '172.16.12.148',
+                    mac_address: '00:03:e6:76:3e:6e',
+                    netmask: '255.255.252.0',
+                    nic_name: 'eth0',
+                    nic_type: 1,
+                }],
+                ntp_last_contacted: 1617704286,
+                ntp_server: '255.255.255.255',
+                num_of_nic: 1,
+            },
+        }),
+        setNetworkEvtCallback: (callback: INetworkCallback) => {
+            entoneState.networkEventCallback = callback;
+        },
+    },
+    stb: {
+        reboot: () => {},
+        getHardwareModel: () => 26, // 26 for Kamai 500
+        getSoftwareVersion: () => '2.9.32_build10-etv-vmx--as3',
+        getSerialNumber: () => '38746151',
+        getAudioVolume: () => ({
+            status_code: ENTONE.status.SUCCESS,
+            leftVolPercentage: entoneState.volumePercentage,
+            rightVolPercentage: entoneState.volumePercentage,
+        }),
+        setAudioVolume: (
+            leftVolPercentage: number,
+            rightVolPercentage: number,
+            callback?: (status: string) => void,
+        ) => {
+            const input = { leftVolPercentage, rightVolPercentage, callback };
+            entoneState.volumePercentage = input.leftVolPercentage;
+        },
+        mute: (isMuted: boolean) => {
+            entoneState.isMuted = isMuted;
+        },
+        getMute: () => entoneState.isMuted,
+    },
+    browser: {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        configUserAgent: (options: {
+            id: number,
+            user_agent_mode: UserAgentMode,
+            user_agent: string,
+        }) => ENTONE.status.SUCCESS,
+    },
+};
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface Window {
+        ENTONE: typeof ENTONE,
+    }
+}

package/packages/driver-hbbtv/src/__mocks__/hbbtv.ts

@@ -0,0 +1,17 @@
+const objectOIPF = document.createElement('object');
+
+export const mockApplication = {
+    show: () => ({}),
+    activate: () => ({}),
+    destroyApplication: () => ({}),
+    privateData: {
+        keyset: {
+            setValue: () => ({}),
+        },
+    },
+};
+
+export const mockApplicationManager = {
+    ...objectOIPF,
+    getOwnerApplication: () => (mockApplication),
+};

package/packages/driver-kreatv/src/__mocks__/toi2.ts

@@ -0,0 +1,76 @@
+import { ToiHTMLEmbedElement } from '../types';
+
+export const toi = {
+    consts: {
+        ToiAudioOutputService: {
+            AUDIO_CONNECTION_TYPE_ANALOG: 0,
+            AUDIO_CONNECTION_TYPE_SPDIF: 1,
+            AUDIO_CONNECTION_TYPE_HDMI: 2,
+        },
+        ToiPowerControl: {
+            ACCESS_REPORT_ONLY: 0,
+            ON_POWER_PROFILE_REQUESTED: 4400,
+            ON_POWER_PROFILE_SELECTED: 4401,
+            PROFILE_ACTIVE: 0,
+        },
+        ToiPlatformService: {
+            REBOOT_TYPE_NOW: 0,
+        },
+        ToiNetService: {
+            ON_DEVICE_INTERFACE_READINESS_CHANGED: 4406,
+        },
+        ToiNetConfiguration: {
+            NET_DEVICE_TYPE_ALL: 255,
+            NET_DEVICE_TYPE_ETHERNET: 1,
+            NET_DEVICE_TYPE_WIFI: 16,
+        },
+        ToiInformationService: {
+            CONST_IP_ETH0_MAC: 'const.ip.eth0.mac',
+            VAR_IP_ETH0_ADDR: 'var.ip.eth0.addr',
+            CONST_FW_VERSION: 'const._fw.version',
+            CONST_HW_PRODUCTNAME: 'const.hw.productname',
+            CONST_HW_SERIALNUMBER: 'const.hw.serialnumber',
+        },
+    },
+    audioOutputService: {
+        getConnections: jest.fn().mockReturnValue([
+            { id: 1, type: 1 },
+            { id: 2, type: 2 },
+            { id: 4, type: 4 },
+        ]),
+        getVolume: jest.fn(),
+        setVolume: jest.fn(),
+        setMuteState: jest.fn(),
+        getMuteState: jest.fn(),
+    },
+    netService: {
+        addEventListener: jest.fn(),
+        getConfiguration: jest.fn().mockReturnValue({
+            getNetworkDevices: jest.fn().mockReturnValue([]),
+            getGenericDeviceInfo: jest.fn(),
+        }),
+    },
+    informationService: {
+        getObject: jest.fn(),
+    },
+    platformService: {
+        reboot: jest.fn(),
+        createPowerControlInstance: jest.fn().mockReturnValue({
+            addEventListener: jest.fn(),
+            reportPowerProfile: jest.fn(),
+            reportPowerProfileActionsComplete: jest.fn(),
+        }),
+    },
+};
+
+export const mockToiHtmlEmbedElement = document.createElement('embed') as ToiHTMLEmbedElement;
+mockToiHtmlEmbedElement.id = 'toiplugin';
+
+export const mockConnectionType = (connectionType?: number) => {
+    toi.netService.getConfiguration.mockReturnValueOnce({
+        getNetworkDevices: jest.fn().mockReturnValueOnce([]),
+        getGenericDeviceInfo: jest.fn().mockReturnValueOnce(
+            { type: connectionType },
+        ),
+    });
+};

package/packages/driver-kreatv/src/__mocks__/toi3.ts

@@ -0,0 +1,43 @@
+/* eslint-disable no-magic-numbers */
+
+export const toi = {
+    version: '',
+    consts: {
+        ToiNetService: {
+            BOOT_NETWORK: '_boot_network_',
+        },
+        ToiNetwork: {
+            ON_NETWORK_INFO_CHANGED: 4500,
+            STATE_READY: 3,
+            INTERFACE_TYPE_ETHERNET: 0,
+            INTERFACE_TYPE_WIFI: 1,
+        },
+    },
+    netService: {
+        getNetwork: jest.fn().mockReturnValue({
+            addEventListener: jest.fn(),
+            getNetworkInfo: jest.fn(),
+        }),
+        getNetworkInterfaces: jest.fn(),
+    },
+};
+
+export const mockConnectionType = (connectionType?: number) => {
+    toi.netService.getNetwork.mockReturnValueOnce({
+        getNetworkInfo: jest.fn().mockReturnValueOnce({
+            interfaceInfo: { type: connectionType },
+        }),
+    });
+};
+
+export const mockXMLHttpRequest = (
+    readyState = 4, status = 200, send: Function = jest.fn(),
+) => {
+    // @ts-ignore - mocking purpose
+    window.XMLHttpRequest = jest.fn().mockImplementation(() => ({
+        open: jest.fn(),
+        send,
+        readyState,
+        status,
+    }));
+};

package/packages/driver-saphi/src/__mocks__/SmartTvA_API.ts

@@ -0,0 +1,11 @@
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const SmartTvA_API = {
+    hasCapability: jest.fn(),
+    exit: jest.fn(),
+};
+
+declare global {
+    interface Window {
+        SmartTvA_API: typeof SmartTvA_API,
+    }
+}

package/packages/driver-saphi/src/__mocks__/userAgent.ts

@@ -0,0 +1,4 @@
+export const mockUserAgent = 'Mozilla/5.0 (Linux armv7l) AppleWebKit/537.36 (KHTML, like Gecko) '
+    + 'Chrome/49.0.2623.112 Safari/537.36 OPR/36.0.2128.0 OMI/4.8.0.129.Driver3.56 , '
+    + '_TV_MT5802/012.004.070.051 (Philips, PUS6162, wireless) CE-HTML/1.0 NETTV/4.6.0 '
+    + 'SignOn/2.0 SmartTvA/5.0.0 en Opera/68.0.3618.31';

package/packages/driver-tizen/src/__mocks__/tizen.ts

@@ -0,0 +1,35 @@
+export const webapis = {
+    network: {
+        addNetworkStateChangeListener: () => {},
+    },
+    productinfo: {
+        getDuid: () => 'guid',
+        getRealModel: () => 'real model',
+        getModelCode: () => 'model code',
+        getFirmware: () => 'firmware',
+    },
+};
+
+export const application = {
+    hide: jest.fn(),
+    exit: jest.fn(),
+};
+
+export const tizen = {
+    application: {
+        getCurrentApplication: () => application,
+    },
+    tvinputdevice: {
+        getSupportedKeys: (): any[] => [],
+        unregisterKey: () => {},
+        registerKey: () => {},
+    },
+};
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface Window {
+        webapis: typeof webapis,
+        tizen: typeof tizen,
+    }
+}

package/packages/driver-webos/src/__mocks__/webos.ts

@@ -0,0 +1,172 @@
+/**
+ * Mocking services response module
+ */
+const mockServices = {
+    timeoutMs: 1,
+    setServiceResponse(serviceId: string, responseId: string, callbackName: string) {
+        const service = this.getService(serviceId);
+        service.selected.responseId = responseId;
+        service.selected.callbackName = callbackName;
+    },
+    getServiceResponse(serviceId: string, responseId: string) {
+        const service = this.getService(serviceId);
+        return service.responses[responseId];
+    },
+    getService(serviceId: string) {
+        return (this.services as any)[serviceId];
+    },
+    services: {
+        'luna://com.webos.service.tv.systemproperty#getSystemInfo': {
+            responses: {
+                success: {
+                    returnValue: true,
+                    modelName: 'LB6700AKR',
+                    firmwareVersion: '3.00.00',
+                    UHD: 'true',
+                    sdkVersion: '1.05.00',
+                },
+                successHD: {
+                    returnValue: true,
+                    modelName: 'LB6700AKR',
+                    firmwareVersion: '3.00.00',
+                    UHD: 'false',
+                    sdkVersion: '1.05.00',
+                },
+                error: {
+                    returnValue: false,
+                    errorCode: 'ERROR_10',
+                    errorText: 'Resource temporarily unavailable',
+                },
+            },
+            selected: {
+                responseId: 'success',
+                callbackName: 'onSuccess',
+            },
+        },
+        'luna://com.webos.service.sm#deviceid/getIDs': {
+            responses: {
+                success: {
+                    returnValue: true,
+                    idList: [{
+                        idType: 'LGUDID',
+                        idValue: '095f142a-xxxx-yyyy',
+                    }],
+                },
+                error: {
+                    returnValue: false,
+                    errorCode: 'ERR.002',
+                    errorText: 'Security Manager Internal Error',
+                },
+            },
+            selected: {
+                responseId: 'success',
+                callbackName: 'onSuccess',
+            },
+        },
+        'luna://com.webos.service.connectionmanager#getStatus': {
+            responses: {
+                successWired: {
+                    returnValue: true,
+                    subscribed: true,
+                    isInternetConnectionAvailable: true,
+                    wired: {
+                        state: 'connected',
+                        netmask: '255.255.254.0',
+                        dns1: '123.456.789.180',
+                        ipAddress: '123.456.789.12',
+                        onInternet: 'yes',
+                        method: 'manual',
+                        gateway: '123.456.789.1',
+                        interfaceName: 'eth0',
+                    },
+                    wifi: {
+                        state: 'disconnected',
+                    },
+                    wifiDirect: {
+                        state: 'disconnected',
+                    },
+                },
+                successWiFi: {
+                    returnValue: true,
+                    subscribed: true,
+                    isInternetConnectionAvailable: true,
+                    wired: {
+                        state: 'disconnected',
+                    },
+                    wifi: {
+                        state: 'connected',
+                        netmask: '255.255.254.0',
+                        ipAddress: '172.0.0.0',
+                        onInternet: 'yes',
+                    },
+                    wifiDirect: {
+                        state: 'disconnected',
+                    },
+                },
+                error: {
+                    returnValue: false,
+                    errorCode: 'ERROR CODE',
+                    errorText: 'Error text',
+                },
+            },
+            selected: {
+                responseId: 'successWired',
+                callbackName: 'onSuccess',
+            },
+        },
+    },
+};
+
+/**
+ * Mocking webOS module
+ */
+export const webOS = {
+    libVersion: '1.2.3',
+    platform: {
+        tv: true,
+    },
+    keyboard: {
+        isShowing: () => false,
+    },
+    service: {
+        request(uri: string, params?: any) {
+            const serviceId = `${uri}#${params.method}`;
+            const mockService = mockServices.getService(serviceId);
+
+            if (mockService) {
+                const { responseId, callbackName } = mockService.selected;
+                const mockResponse = mockService.responses[responseId];
+
+                setTimeout(() => {
+                    params[callbackName].call(this, mockResponse);
+                }, mockService.timeoutMs);
+            }
+        },
+    },
+    mockServices,
+    deviceInfo: (callback: (deviceInfo: Object) => void) => {
+        callback({
+            modelName: 'webos model name',
+            modelNameAscii: 'webos name ascii',
+            version: 'webos version 3.4.5',
+            sdkVersion: 'webos sdkversion 3.3.0',
+            screenWidth: 1920,
+            screenHeight: 1080,
+            uhd: false,
+            uhd8K: false,
+        });
+    },
+    fetchAppId: () => 'com.24i.mock',
+};
+
+export const PalmSystem = {
+    deactivate: jest.fn(),
+};
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface Window {
+        webOS: typeof webOS,
+        PalmSystem: typeof PalmSystem,
+    }
+}

package/packages/driver-xbox/src/__mocks__/Windows.ts

@@ -0,0 +1,94 @@
+import {
+    DeviceInformation,
+    HostName,
+    InternetConnectionProfile,
+    IVirtualKey,
+    NetworkConnectivityLevel,
+    Windows as IWindows,
+} from '../interfaces';
+
+const networkAdapter = {
+    networkAdapterId: 'networkAdapterId',
+};
+
+export const getNetworkConnectivityLevel = jest.fn(() => NetworkConnectivityLevel.internetAccess);
+
+class EasClientDeviceInformation implements DeviceInformation {
+    friendlyName = 'friendlyName';
+
+    id = 'id';
+
+    operatingSystem = 'operatingSystem';
+
+    systemFirmwareVersion = 'systemFirmwareVersion';
+
+    systemHardwareVersion = 'systemHardwareVersion';
+
+    systemManufacturer = 'systemManufacturer';
+
+    systemProductName = 'systemProductName';
+
+    systemSku = 'systemSku';
+}
+
+export const Windows: IWindows = {
+    Networking: {
+        Connectivity: {
+            NetworkConnectivityLevel,
+            NetworkInformation: {
+                getHostNames: jest.fn((): HostName[] => ([{
+                    ipInformation: {
+                        networkAdapter,
+                    },
+                }])),
+                getInternetConnectionProfile: jest.fn((): InternetConnectionProfile => ({
+                    networkAdapter,
+                    getNetworkConnectivityLevel,
+                    isWlanConnectionProfile: true,
+                })),
+                onnetworkstatuschanged: () => {},
+            },
+        },
+    },
+    Security: {
+        ExchangeActiveSyncProvisioning: {
+            EasClientDeviceInformation,
+        },
+    },
+    Storage: {
+        ApplicationData: {
+            current: {
+                localSettings: {
+                    values: {
+                        storedUuid: '11b4a2a3-cd33-46e6-b43f-a0c2a42427e6',
+                    },
+                },
+            },
+        },
+    },
+    System: {
+        VirtualKey: {
+            left: 37,
+            up: 38,
+            right: 39,
+            down: 40,
+            enter: 13,
+            back: 8,
+        } as IVirtualKey,
+        Profile: {
+            AnalyticsInfo: {
+                versionInfo: {
+                    deviceFamilyVersion: '2814750438211613',
+                },
+            },
+        },
+    },
+};
+
+window.Windows = Windows;
+
+declare global {
+    interface Window {
+        Windows: IWindows,
+    }
+}

package/packages/gallup/src/__mocks__/SpringStreams.js

@@ -0,0 +1,18 @@
+const streamSpy = {
+    stop: jest.fn(),
+};
+
+const sensorsSpy = {
+    track: jest.fn(() => streamSpy),
+    unload: jest.fn(),
+    debug: undefined,
+};
+
+const SpringStreams = jest.fn(() => sensorsSpy);
+
+window.SpringStreams = SpringStreams;
+
+module.exports = {
+    streamSpy,
+    sensorsSpy,
+};

package/packages/input/__mocks__/MockKeyboard.ts

@@ -0,0 +1,40 @@
+export class MockKeyboard {
+    listener: Function | null = null;
+
+    resolver: Function | null = null;
+
+    inputElement: HTMLInputElement | null = null;
+
+    promise: Promise<void> | null = null;
+
+    input: (input: HTMLInputElement) => Promise<void> = jest.fn(
+        (inputElement: HTMLInputElement) => {
+            this.promise = new Promise((resolve) => {
+                this.inputElement = inputElement;
+                this.resolver = resolve;
+            });
+            return this.promise;
+        },
+    );
+
+    done = () => {
+        if (this.resolver) {
+            this.inputElement = null;
+            this.resolver();
+            this.resolver = null;
+        }
+    };
+
+    addEventListener = (_: any, listener: Function) => {
+        this.listener = listener;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    removeEventListener = (_: any, listener: any) => {
+        this.listener = null;
+    };
+
+    triggerEvent = (payload: any) => {
+        if (this.listener) this.listener(payload);
+    };
+}

package/packages/logger/src/__mocks__/LoggerBase.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { LoggerBase as AbstractLoggerBase } from '../loggers/LoggerBase';
+import { LogOptions } from '../types';
+
+export class LoggerBase extends AbstractLoggerBase {
+    debug(message: string, options?: LogOptions) {}
+
+    info(message: string, options?: LogOptions) {}
+
+    warn(message: string, options?: LogOptions) {}
+
+    error(message: string, options?: LogOptions) {}
+}

package/packages/logger/src/loggers/SentryLogger/mock.ts

@@ -0,0 +1,6 @@
+import { Sentry } from './Sentry';
+
+jest.mock('./Sentry');
+
+export { SentryLogger } from './SentryLogger';
+export { Sentry };

package/packages/utils/src/xhr/__mocks__/xhr.ts

@@ -0,0 +1,29 @@
+function mockXhr(status?: number, responseData?: string) {
+    const mockXhrObj = {
+        open: jest.fn(),
+        send: jest.fn(),
+        ontimeout: jest.fn(),
+        onerror: jest.fn(),
+        onabort: jest.fn(),
+        onload: jest.fn(),
+        setRequestHeader: jest.fn(),
+        readyState: 4,
+        status,
+        response: responseData,
+        timeout: undefined as undefined | number,
+    };
+
+    const mockXhrClass = () => mockXhrObj;
+
+    // @ts-ignore - Needed for mocking purposes
+    window.XMLHttpRequest = jest.fn().mockImplementation(mockXhrClass);
+
+    setTimeout(() => {
+        // @ts-ignore - Needed for mocking purposes
+        mockXhrObj.onload();
+    }, 0);
+
+    return mockXhrObj;
+}
+
+export { mockXhr };

package/packages/volume-control/src/__mocks__/VolumeControlUIMock.tsx

@@ -0,0 +1,18 @@
+import { Component } from '@24i/bigscreen-sdk/jsx';
+import { IVolumeControlUI } from '../IVolumeControlUI';
+
+export class VolumeControlUIMock extends Component<{}> implements IVolumeControlUI {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onUpdateVolume(volumeLevel: number) {}
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onUpdateMute(isMuted: boolean) {}
+
+    show = () => {};
+
+    hide = () => {};
+
+    isVisible() { return true; }
+
+    render() { return <div className="volume-control-ui" />; }
+}