import 'reflect-metadata';

import {
    requiredMocks,
} from './../../../../test-mocks';
requiredMocks(jest);

import {
    ErrorLoggingService,
} from './error-logging.service';

import {
    DefaultTrackingService,
} from './../index';

const initErrorLoggingService = (
    window?: Window,
    defaultTrackingService?: DefaultTrackingService,
) => {
    return new ErrorLoggingService(
        window,
        defaultTrackingService,
    );
};

describe('init', () => {
    // tslint:disable-next-line
    test('It adds an error event listener to the window', () => {
        const window = {} as Window;
        const addEventListenerMock = jest.fn();
        window.addEventListener = addEventListenerMock;
        const errorLoggingService = initErrorLoggingService(
            window,
        );

        errorLoggingService.init();

        expect(addEventListenerMock.mock.calls[0][0])
        .toBe('error');
    });

    // tslint:disable-next-line
    test('It calling the error event should trigger the error getting passed to logError', () => {
        const window = {} as Window;
        const addEventListenerMock = jest.fn();
        window.addEventListener = addEventListenerMock;
        const errorLoggingService = initErrorLoggingService(
            window,
        );
        errorLoggingService.logError = jest.fn();
        const errorEvent = {
            error: {},
        } as ErrorEvent;

        errorLoggingService.init();
        addEventListenerMock.mock.calls[0][1](errorEvent);

        expect(errorLoggingService.logError)
        .toHaveBeenCalledWith(errorEvent.error);
    });
});

describe('logError', () => {
    // tslint:disable-next-line
    test('It sends the correct event', () => {
        const defaultTrackingService = {} as DefaultTrackingService;
        defaultTrackingService.sendEvent = jest.fn();
        const errorLoggingService = initErrorLoggingService(
            undefined,
            defaultTrackingService,
        );
        const error = {
            message: 'messagetest',
            name: 'nametest',
            stack: {},
        } as Error;

        errorLoggingService.logError(error);

        expect(defaultTrackingService.sendEvent)
        .toHaveBeenCalledWith({
            name: 'Error',
            properties: {
                errorMessage: error.message,
                errorName: error.name,
                stack: error.stack,
            },
        });
    });
});