@yoroi/portfolio/lib/commonjs/adapters/mmkv-storage/token-storage-maker.test.js

The Portfolio package of Yoroi SDK

"use strict";

var _common = require("@yoroi/common");
var _tokenStorageMaker = require("./token-storage-maker");
var _token = require("../token.mocks");
var _tokenInfo = require("../token-info.mocks");
// Adjust the path accordingly

describe('portfolioTokenStorageMaker', () => {
  let tokenInfoStorage;
  beforeEach(() => {
    tokenInfoStorage = createMockStorage('v2/mainnet/token-info/');
    tokenInfoStorage.clear();
    jest.clearAllMocks();
  });
  it('should instantiate storage', () => {
    const storage = (0, _tokenStorageMaker.portfolioTokenStorageMaker)({
      tokenInfoStorage
    });
    expect(storage).toBeDefined();
    expect(Object.isFrozen(storage)).toBe(true);
  });
  it('should save token info entries', () => {
    const nftCryptoKitty = _token.tokenMocks.nftCryptoKitty.info;
    const primaryETH = _token.tokenMocks.primaryETH.info;
    const {
      token
    } = (0, _tokenStorageMaker.portfolioTokenStorageMaker)({
      tokenInfoStorage
    });
    const entries = [[nftCryptoKitty.id, (0, _common.cacheRecordMaker)({
      expires: 0,
      hash: ''
    }, nftCryptoKitty)], [primaryETH.id, (0, _common.cacheRecordMaker)({
      expires: 0,
      hash: ''
    }, primaryETH)]];
    token.infos.save(entries);
    expect(tokenInfoStorage.multiSet).toHaveBeenCalledWith(entries, _common.storageSerializer);
  });
  it('should read token info entries', () => {
    const nftCryptoKitty = _token.tokenMocks.nftCryptoKitty.info;
    const primaryETH = _token.tokenMocks.primaryETH.info;
    const {
      token
    } = (0, _tokenStorageMaker.portfolioTokenStorageMaker)({
      tokenInfoStorage
    });
    const entries = [[nftCryptoKitty.id, (0, _common.cacheRecordMaker)({
      expires: 0,
      hash: ''
    }, nftCryptoKitty)], [primaryETH.id, (0, _common.cacheRecordMaker)({
      expires: 0,
      hash: ''
    }, primaryETH)]];
    token.infos.save(entries);
    const keys = [nftCryptoKitty.id, primaryETH.id];
    const result = token.infos.read(keys);
    expect(result).toEqual(entries);
    expect(tokenInfoStorage.multiGet).toHaveBeenCalledWith(keys);
  });
  it('should clear all portfolio records', () => {
    const {
      token,
      clear
    } = (0, _tokenStorageMaker.portfolioTokenStorageMaker)({
      tokenInfoStorage
    });
    token.infos.save(_tokenInfo.tokenInfoMocks.storage.entries1);
    let infoResult = token.infos.all();
    expect(infoResult).toEqual(_tokenInfo.tokenInfoMocks.storage.entries1);
    clear();
    infoResult = token.infos.all();

    // keys are gone
    expect(infoResult).toEqual([]);
    expect(tokenInfoStorage.clear).toHaveBeenCalled();
  });
  it('should return all keys', () => {
    const {
      token
    } = (0, _tokenStorageMaker.portfolioTokenStorageMaker)({
      tokenInfoStorage
    });
    token.infos.save(_tokenInfo.tokenInfoMocks.storage.entries1);
    let infoResult = token.infos.keys();
    expect(infoResult).toEqual([...new Map(_tokenInfo.tokenInfoMocks.storage.entries1).keys()]);
  });
  it('should call clear', () => {
    const {
      token
    } = (0, _tokenStorageMaker.portfolioTokenStorageMaker)({
      tokenInfoStorage
    });
    token.infos.clear();
    expect(tokenInfoStorage.clear).toHaveBeenCalled();
  });
});
function createMockStorage() {
  let path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '/';
  let deserializer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : JSON.parse;
  let serializer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _common.storageSerializer;
  let storage = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
  let subscriptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : new Set();
  const withPath = key => `${path}${key}`;
  return {
    join: jest.fn(folderName => createMockStorage(`${path}${folderName}`, deserializer, serializer, storage, subscriptions)),
    getItem: jest.fn(function (key) {
      let parser = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : deserializer;
      const item = storage.get(withPath(key)) ?? null;
      return parser(item);
    }),
    multiGet: jest.fn(function (keys) {
      let parser = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : deserializer;
      return keys.map(key => [key, parser(storage.get(withPath(key)) ?? null)]);
    }),
    setItem: jest.fn(function (key, value) {
      let stringifier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : serializer;
      storage.set(withPath(key), stringifier(value));
    }),
    multiSet: jest.fn(function (tuples) {
      let stringifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : serializer;
      tuples.forEach(_ref => {
        let [key, value] = _ref;
        storage.set(withPath(key), stringifier(value));
      });
    }),
    removeItem: jest.fn(key => {
      storage.delete(withPath(key));
    }),
    removeFolder: jest.fn(folderName => {
      const prefix = `${path}${folderName}`;
      const keysToRemove = [...storage.keys()].filter(key => key.startsWith(prefix));
      keysToRemove.forEach(key => storage.delete(key));
    }),
    multiRemove: jest.fn(keys => {
      keys.forEach(key => storage.delete(withPath(key)));
    }),
    getAllKeys: jest.fn(() => {
      const withoutPath = absolutePath => absolutePath.slice(path.length);
      return [...storage.keys()].filter(key => key.startsWith(path)).map(key => withoutPath(key));
    }),
    clear: jest.fn(() => {
      storage.clear();
    }),
    onChange: jest.fn((_keysToObserve, callback) => {
      subscriptions.add(callback);
      return {
        unsubscribe: jest.fn(() => {
          subscriptions.delete(callback);
        })
      };
    })
  };
}
//# sourceMappingURL=token-storage-maker.test.js.map