@yoroi/portfolio/lib/module/validators/token-discovery.test.js

The Portfolio package of Yoroi SDK

import { isTokenDiscovery, parseTokenDiscovery, TokenDiscoveryResponseWithCacheRecordSchema, isTokenDiscoveryResponseWithCacheRecord, parseTokenDiscoveryResponseWithCacheRecord, parseTokenDiscoveryWithCacheRecord, isTokenDiscoveryWithCacheRecord } from './token-discovery';
import { tokenDiscoveryMocks } from '../adapters/token-discovery.mocks';
describe('isTokenDiscovery', () => {
  it('should return true for a valid token discovery', () => {
    const validTokenDiscovery = tokenDiscoveryMocks.nftCryptoKitty;
    const result = isTokenDiscovery(validTokenDiscovery);
    expect(result).toBe(true);
  });
  it('should return false for an invalid token discovery', () => {
    const invalidTokenDiscovery = {
      ...tokenDiscoveryMocks.primaryETH,
      id: 'invalid'
    };
    const result = isTokenDiscovery(invalidTokenDiscovery);
    expect(result).toBe(false);
  });
});
describe('parseTokenDiscovery', () => {
  it('should return a valid token discovery', () => {
    const validTokenDiscovery = tokenDiscoveryMocks.nftCryptoKitty;
    const result = parseTokenDiscovery(validTokenDiscovery);
    expect(result).toEqual(validTokenDiscovery);
  });
  it('should return undefined for an invalid token discovery', () => {
    const invalidTokenDiscovery = {
      ...tokenDiscoveryMocks.primaryETH,
      id: 'invalid'
    };
    const result = parseTokenDiscovery(invalidTokenDiscovery);
    expect(result).toBeUndefined();
  });
});
describe('TokenDiscoveryResponseWithCacheRecordSchema', () => {
  it('should validate a valid token discovery response with cache record', () => {
    const validResponse = [200, tokenDiscoveryMocks.nftCryptoKitty, 'hash', 100];
    const result = TokenDiscoveryResponseWithCacheRecordSchema.safeParse(validResponse);
    expect(result.success).toBe(true);
  });
  it('should not validate an invalid token discovery response with cache record', () => {
    const invalidTokenDiscovery = {
      ...tokenDiscoveryMocks.primaryETH,
      id: 'invalid'
    };
    const invalidResponse = [200, invalidTokenDiscovery, 'hash', 100];
    const result = TokenDiscoveryResponseWithCacheRecordSchema.safeParse(invalidResponse);
    expect(result.success).toBe(false);
  });
});
describe('isTokenDiscoveryResponseWithCacheRecord', () => {
  it('should return true for a valid token discovery response with cache record', () => {
    const validResponse = [200, tokenDiscoveryMocks.nftCryptoKitty, 'hash', 100];
    const result = isTokenDiscoveryResponseWithCacheRecord(validResponse);
    expect(result).toBe(true);
  });
  it('should return false for an invalid token discovery response with cache record', () => {
    const invalidTokenDiscovery = {
      ...tokenDiscoveryMocks.primaryETH,
      id: 'invalid'
    };
    const invalidResponse = [200, invalidTokenDiscovery, 'hash', 100];
    const result = isTokenDiscoveryResponseWithCacheRecord(invalidResponse);
    expect(result).toBe(false);
  });
});
describe('parseTokenDiscoveryResponseWithCacheRecord', () => {
  it('should return a valid token discovery response with cache record', () => {
    const validResponse = [200, tokenDiscoveryMocks.nftCryptoKitty, 'hash', 100];
    const result = parseTokenDiscoveryResponseWithCacheRecord(validResponse);
    expect(result).toEqual(validResponse);
  });
  it('should return undefined for an invalid token discovery response with cache record', () => {
    const invalidTokenDiscovery = {
      ...tokenDiscoveryMocks.primaryETH,
      id: 'invalid'
    };
    const invalidResponse = [200, invalidTokenDiscovery, 'hash', 100];
    const result = parseTokenDiscoveryResponseWithCacheRecord(invalidResponse);
    expect(result).toBeUndefined();
  });
});
describe('parseTokenDiscoveryWithCacheRecord', () => {
  it('should return a valid token discovery with cache record', () => {
    const validTokenDiscovery = tokenDiscoveryMocks.nftCryptoKitty;
    const validCache = {
      hash: 'hash',
      expires: 100,
      record: validTokenDiscovery
    };
    const result = parseTokenDiscoveryWithCacheRecord(validCache);
    expect(result).toBe(validCache);
  });
  it('should return undefined for an invalid token discovery with cache record', () => {
    const invalidTokenDiscovery = {
      ...tokenDiscoveryMocks.primaryETH,
      id: 'invalid'
    };
    const invalidCache = {
      hash: 'hash',
      expires: 100,
      record: invalidTokenDiscovery
    };
    const result = parseTokenDiscoveryWithCacheRecord(invalidCache);
    expect(result).toBeUndefined();
  });
});
describe('isTokenDiscoveryWithCacheRecord', () => {
  it('should return true for a valid token discovery with cache record', () => {
    const validTokenDiscovery = tokenDiscoveryMocks.nftCryptoKitty;
    const validCache = {
      hash: 'hash',
      expires: 100,
      record: validTokenDiscovery
    };
    const result = isTokenDiscoveryWithCacheRecord(validCache);
    expect(result).toBe(true);
  });
  it('should return false for an invalid token discovery with cache record', () => {
    const invalidTokenDiscovery = {
      ...tokenDiscoveryMocks.primaryETH,
      id: 'invalid'
    };
    const invalidCache = {
      hash: 'hash',
      expires: 100,
      record: invalidTokenDiscovery
    };
    const result = isTokenDiscoveryWithCacheRecord(invalidCache);
    expect(result).toBe(false);
  });
});
//# sourceMappingURL=token-discovery.test.js.map