import * as mock from '../../../mocks/index';
import { ErrorLoggingService } from './../index';
import { LocalStorageService } from './local-storage.service';

const initStorageService = (errorLoggingService?: ErrorLoggingService) => {
    return new LocalStorageService(errorLoggingService);
};

const initLocalStorageMock = mock.localStorage(jest);

const overwriteStoragePrototype = (storageMock: Storage) => {
    Storage.prototype.getItem = storageMock.getItem;
    Storage.prototype.clear = storageMock.clear;
    Storage.prototype.removeItem = storageMock.removeItem;
    Storage.prototype.setItem = storageMock.setItem;
};

describe('get', () => {
    test('It calls getItem on the localStorage', () => {
        const storageService = initStorageService();
        const localStorageMock = initLocalStorageMock();
        localStorageMock.getItem = jest.fn().mockReturnValue('{ "test": 1 }');

        overwriteStoragePrototype(localStorageMock);
        storageService.get('test');

        expect(window.localStorage.getItem).toHaveBeenCalledWith('test');
    });

    test('It returns the JSON parsed response from getItem on the localStorage', () => {
        const storageService = initStorageService();
        const localStorageMock = initLocalStorageMock();
        localStorageMock.getItem = jest.fn().mockReturnValue('{"test":1}');

        overwriteStoragePrototype(localStorageMock);
        const response = storageService.get('test');

        expect(response).toEqual({ test: 1 });
    });

    test('It returns null if getItem does not find a record', () => {
        const storageService = initStorageService();
        const localStorageMock = initLocalStorageMock();
        localStorageMock.getItem = jest.fn().mockReturnValue(null);

        overwriteStoragePrototype(localStorageMock);
        const response = storageService.get('test');

        expect(response).toBeNull();
    });

    test('It calls errorLogginService.logError if getItem throws an error', () => {
        const errorLoggingService = {} as ErrorLoggingService;
        errorLoggingService.logError = jest.fn();
        const storageService = initStorageService(errorLoggingService);
        const localStorageMock = initLocalStorageMock();
        const error = new Error();
        localStorageMock.getItem = jest.fn()
            .mockImplementationOnce(() => {
                throw error;
            });

        overwriteStoragePrototype(localStorageMock);
        storageService.get('test');

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

describe('set', () => {
    test('It calls setItem on the localStorage', () => {
        const storageService = initStorageService();
        const data = {};

        overwriteStoragePrototype(initLocalStorageMock());
        storageService.set('test', data);

        expect(window.localStorage.setItem).toHaveBeenCalledWith('test', JSON.stringify(data));
    });

    test('It calls errorLogginService.logError if setItem throws an error', () => {
        const errorLoggingService = {} as ErrorLoggingService;
        errorLoggingService.logError = jest.fn();
        const storageService = initStorageService(errorLoggingService);
        const error = new Error();
        const data = {};
        const localStorageMock = initLocalStorageMock();
        localStorageMock.setItem = jest.fn()
            .mockImplementationOnce(() => {
                throw error;
            });

        overwriteStoragePrototype(localStorageMock);
        storageService.set('test', data);

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

describe('clear', () => {
    test('It calls localStorage.clear', () => {
        const storageService = initStorageService();
        overwriteStoragePrototype(initLocalStorageMock());

        storageService.clear();

        expect(window.localStorage.clear).toHaveBeenCalled();
    });

    test('It calls errorLogginService.logError if localStorage.clear throws an error', () => {
        const errorLoggingService = {} as ErrorLoggingService;
        errorLoggingService.logError = jest.fn();
        const storageService = initStorageService(
            errorLoggingService,
        );
        const error = new Error();

        const localStorageMock = initLocalStorageMock();
        localStorageMock.clear = jest.fn()
            .mockImplementationOnce(() => {
                throw error;
            });

        overwriteStoragePrototype(localStorageMock);
        storageService.clear();

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

describe('removeItem', () => {
    test('It calls localStorage.removeItem', () => {
        const storageService = initStorageService();
        overwriteStoragePrototype(initLocalStorageMock());

        storageService.removeItem('test');

        expect(window.localStorage.removeItem).toHaveBeenCalledWith('test');
    });

    test('It calls errorLogginService.logError if localStorage.clear throws an error', () => {
        const errorLoggingService = {} as ErrorLoggingService;
        errorLoggingService.logError = jest.fn();
        const storageService = initStorageService(
            errorLoggingService,
        );
        const error = new Error();
        const localStorageMock = initLocalStorageMock();
        localStorageMock.removeItem = jest.fn()
            .mockImplementationOnce(() => {
                throw error;
            });

        overwriteStoragePrototype(localStorageMock);
        storageService.removeItem('test');

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