@24i/bigscreen-sdk 0.9.9-alpha.2148 → 0.9.9-alpha.2150

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);
+    };
+}