@yoroi/common/lib/commonjs/translators/reactjs/hooks/useSyncStorageToState.test.js

The Common package of Yoroi SDK

"use strict";

var _react = require("@testing-library/react");
var _storageKeyMaker = require("../../../storage/helpers/storage-key-maker");
var _useSyncStorageToState = require("./useSyncStorageToState");
describe('useSyncStorageToState', () => {
  const mockUnsubscribe = jest.fn();
  const mockStorage = {
    setItem: jest.fn(),
    getItem: jest.fn(),
    removeItem: jest.fn(),
    clear: jest.fn(),
    multiSet: jest.fn(),
    multiGet: jest.fn(),
    multiRemove: jest.fn(),
    getAllKeys: jest.fn(),
    join: jest.fn(),
    removeFolder: jest.fn(),
    onChange: jest.fn().mockReturnValue({
      unsubscribe: mockUnsubscribe
    }),
    observable: {
      source: undefined,
      operator: undefined,
      subscribe: jest.fn(),
      lift: jest.fn(),
      forEach: jest.fn(),
      pipe: jest.fn(),
      toPromise: jest.fn()
    }
  };
  const createKeyManager = key => {
    const keyManager = {
      key,
      subscribe: jest.fn(() => {
        return {
          unsubscribe: mockUnsubscribe,
          closed: false
        };
      }),
      read: () => {
        const value = mockStorage.getItem(key, item => {
          if (!item) return null;
          try {
            return JSON.parse(item);
          } catch {
            return null;
          }
        });
        return value;
      },
      save: value => {
        mockStorage.setItem(key, value);
      },
      remove: () => {
        mockStorage.removeItem(key);
      }
    };
    return keyManager;
  };
  beforeEach(() => {
    jest.clearAllMocks();
  });
  it('should initialize with null value', async () => {
    const key = 'test-key';
    const keyManager = createKeyManager(key);
    mockStorage.getItem.mockReturnValue(null);
    const {
      result
    } = (0, _react.renderHook)(() => (0, _useSyncStorageToState.useSyncStorageToState)(keyManager));
    await (0, _react.waitFor)(() => {
      expect(result.current[0]).toBe(null);
    });
  });
  it('should read initial value from storage', () => {
    const key = 'test-key';
    const value = {
      data: 'test'
    };
    const keyManager = createKeyManager(key);
    mockStorage.getItem.mockImplementation((k, parse) => {
      if (k === key) {
        return parse ? parse(JSON.stringify(value)) : value;
      }
      return null;
    });
    const {
      result
    } = (0, _react.renderHook)(() => (0, _useSyncStorageToState.useSyncStorageToState)(keyManager));
    expect(mockStorage.getItem).toHaveBeenCalledWith(key, expect.any(Function));
    expect(result.current[0]).toEqual(value);
  });
  it('should update value when storage changes', () => {
    const key = 'test-key';
    const initialValue = {
      data: 'initial'
    };
    const newValue = {
      data: 'updated'
    };
    let subscribeCallback;
    const keyManager = {
      ...createKeyManager(key),
      subscribe: jest.fn(cb => {
        subscribeCallback = cb;
        return {
          unsubscribe: mockUnsubscribe,
          closed: false
        };
      })
    };
    mockStorage.getItem.mockImplementation((k, parse) => {
      if (k === key) {
        return parse ? parse(JSON.stringify(initialValue)) : initialValue;
      }
      return null;
    });
    const {
      result
    } = (0, _react.renderHook)(() => (0, _useSyncStorageToState.useSyncStorageToState)(keyManager))

    // Simulate storage change
    ;
    mockStorage.getItem.mockImplementation((k, parse) => {
      if (k === key) {
        return parse ? parse(JSON.stringify(newValue)) : newValue;
      }
      return null;
    });
    (0, _react.act)(() => {
      if (subscribeCallback) {
        subscribeCallback();
      }
    });
    return (0, _react.waitFor)(() => {
      expect(result.current[0]).toEqual(newValue);
    });
  });
  it('should save value to storage', () => {
    const key = 'test-key';
    const value = {
      data: 'test'
    };
    const keyManager = createKeyManager(key);
    const {
      result
    } = (0, _react.renderHook)(() => (0, _useSyncStorageToState.useSyncStorageToState)(keyManager));
    (0, _react.act)(() => {
      const save = result.current[1];
      if (typeof save === 'function') {
        save(value);
      }
    });
    expect(mockStorage.setItem).toHaveBeenCalledWith(key, value);
  });
  it('should remove value from storage', () => {
    const key = 'test-key';
    const keyManager = createKeyManager(key);
    const {
      result
    } = (0, _react.renderHook)(() => (0, _useSyncStorageToState.useSyncStorageToState)(keyManager));
    (0, _react.act)(() => {
      const remove = result.current[2];
      if (typeof remove === 'function') {
        remove();
      }
    });
    expect(mockStorage.removeItem).toHaveBeenCalledWith(key);
  });
  it('should unsubscribe when unmounted', () => {
    const key = 'test-key';
    const keyManager = createKeyManager(key);
    const {
      unmount
    } = (0, _react.renderHook)(() => (0, _useSyncStorageToState.useSyncStorageToState)(keyManager));
    unmount();
    expect(mockUnsubscribe).toHaveBeenCalled();
  });
  it('should call storage.onChange with correct arguments when subscribing', () => {
    const key = 'test-key';
    const parser = data => data ? JSON.parse(data) : null;
    const keyManager = (0, _storageKeyMaker.storageKeyMaker)(mockStorage)({
      key,
      parser
    });
    (0, _react.renderHook)(() => (0, _useSyncStorageToState.useSyncStorageToState)(keyManager));
    expect(mockStorage.onChange).toHaveBeenCalledWith([key], expect.any(Function));
  });
});
//# sourceMappingURL=useSyncStorageToState.test.js.map