@thoughtspot/visual-embed-sdk/lib/src/utils/reporting.spec.js

ThoughtSpot Embed SDK

import { setEmbedConfig } from '../embed/embedConfig';
import { registerReportingObserver, getGlobalReportingObserver, resetGlobalReportingObserver } from './reporting';
import { logger } from './logger';
import { AuthType } from '../types';
import { ERROR_MESSAGE } from '../errors';
jest.mock('./logger');
describe('ReportingObserver', () => {
    let mockReportingObserver;
    beforeAll(() => {
        // Mock the ReportingObserver
        mockReportingObserver = jest.fn().mockImplementation((callback, options) => ({
            observe: jest.fn(),
            disconnect: jest.fn(),
            takeRecords: jest.fn(),
        }));
        window.ReportingObserver = mockReportingObserver;
    });
    afterEach(() => {
        jest.clearAllMocks();
        resetGlobalReportingObserver();
    });
    test('should warn if ReportingObserver is not supported', () => {
        window.ReportingObserver = undefined;
        const observer = registerReportingObserver();
        expect(observer).toBeNull();
        expect(logger.warn).toHaveBeenCalledWith('ReportingObserver not supported');
        window.ReportingObserver = mockReportingObserver;
    });
    test('should return existing globalObserver if override is false', () => {
        const firstObserver = registerReportingObserver();
        const secondObserver = registerReportingObserver();
        expect(firstObserver === secondObserver).toBe(true);
    });
    test('should override existing globalObserver if override is true', () => {
        const firstObserver = registerReportingObserver();
        const secondObserver = registerReportingObserver(true);
        expect(firstObserver).not.toBe(secondObserver);
    });
    test('should return globalObserver', () => {
        const observer = registerReportingObserver();
        const globalObserver = getGlobalReportingObserver();
        expect(globalObserver).toBe(observer);
    });
    test('Should register a global observer with callback', () => {
        let callBackPassed;
        // Mock the ReportingObserver
        const NewMockRO = jest.fn().mockImplementation((callback, options) => {
            callBackPassed = callback;
            return ({
                observe: jest.fn(),
                disconnect: jest.fn(),
                takeRecords: jest.fn(),
            });
        });
        const currentObserver = window.ReportingObserver;
        window.ReportingObserver = NewMockRO;
        setEmbedConfig({
            thoughtSpotHost: 'testHost',
            authType: AuthType.None,
        });
        const mockAlert = jest.fn();
        window.alert = mockAlert;
        const observer = registerReportingObserver();
        expect(observer).toBeDefined();
        expect(NewMockRO).toHaveBeenCalled();
        expect(callBackPassed).toBeDefined();
        // call the callback
        callBackPassed([{ type: 'csp-violation', url: 'testHost', body: { effectiveDirective: 'frame-ancestors' } }]);
        expect(mockAlert).toHaveBeenCalledWith(ERROR_MESSAGE.CSP_VIOLATION_ALERT);
        expect(logger.error).toHaveBeenCalledWith(ERROR_MESSAGE.CSP_FRAME_HOST_VIOLATION_LOG_MESSAGE);
        window.ReportingObserver = currentObserver;
    });
});
//# sourceMappingURL=reporting.spec.js.map