@yoroi/resolver/lib/commonjs/adapters/cns/api.test.js

Yoroi domain resolver

"use strict";

var _crossCslNodejs = require("@emurgo/cross-csl-nodejs");
var _types = require("@yoroi/types");
var _zod = require("zod");
var _api = require("./api");
var _apiHelpers = require("./api-helpers");
jest.mock('./api-helpers');
describe('cnsCryptoAddress', () => {
  beforeEach(jest.clearAllMocks);
  it('should return an address for a valid receiver in mainnet', async () => {
    const cls = _crossCslNodejs.init;
    const receiver = 'fake.ada';
    const address = 'fake-address';
    const isMainnet = true;

    // @ts-ignore
    _apiHelpers.resolveAddress.mockReturnValue(address);
    const getAddress = (0, _api.cnsCryptoAddress)(cls, isMainnet);
    await expect(getAddress(receiver)).resolves.toBe(address);
  });
  it('should return an address for a valid receiver  in preprod', async () => {
    const cls = _crossCslNodejs.init;
    const receiver = 'fake.ada';
    const address = 'fake-address';
    const isMainnet = false;

    // @ts-ignore
    _apiHelpers.resolveAddress.mockReturnValue(address);
    const getAddress = (0, _api.cnsCryptoAddress)(cls, isMainnet);
    await expect(getAddress(receiver)).resolves.toBe(address);
  });
  it('should throw invalid domain error', async () => {
    const cls = _crossCslNodejs.init;
    const receiver = 'fake-wrong-domain';
    try {
      const getAddress = (0, _api.cnsCryptoAddress)(cls);
      await getAddress(receiver);
      fail('it should crash before');
    } catch (e) {
      expect(e).toBeInstanceOf(_types.Resolver.Errors.InvalidDomain);
    }
  });
  it('should throw unssupported tld error', async () => {
    const cls = _crossCslNodejs.init;
    const receiver = 'fake-wrong-domain.com';
    try {
      const getAddress = (0, _api.cnsCryptoAddress)(cls);
      await getAddress(receiver);
      fail('it should crash before');
    } catch (e) {
      expect(e).toBeInstanceOf(_types.Resolver.Errors.UnsupportedTld);
    }
  });
  it('should catch a resolveAddress error', async () => {
    const cls = _crossCslNodejs.init;
    const receiver = 'domain.ada';
    const error = new Error('random');
    // @ts-ignore
    _apiHelpers.resolveAddress.mockImplementation(() => {
      throw error;
    });
    try {
      const getAddress = (0, _api.cnsCryptoAddress)(cls);
      await getAddress(receiver);
      fail('it should crash before');
    } catch (e) {
      expect(e.message).toBe(error.message);
    }
  });
});
describe('handleCnsApiError', () => {
  it('throws invalid response error', () => {
    const mockIssues = [{
      // @ts-ignore
      code: 'some_error_code',
      path: ['field1'],
      message: 'Invalid field1'
    }];
    const zodError = new _zod.ZodError(mockIssues);
    try {
      (0, _api.handleCnsApiError)(zodError);
      fail('it should crash before');
    } catch (e) {
      expect(e).toBeInstanceOf(_types.Resolver.Errors.InvalidResponse);
    }
  });
  it('throws resolver not found error', () => {
    const notFoundError = new _types.Api.Errors.NotFound();
    try {
      (0, _api.handleCnsApiError)(notFoundError);
      fail('it should crash before');
    } catch (e) {
      expect(e).toBeInstanceOf(_types.Resolver.Errors.NotFound);
    }
  });
  it('throws unknown error', () => {
    const unknownError = new Error('unknown error');
    try {
      (0, _api.handleCnsApiError)(unknownError);
      fail('it should crash before');
    } catch (e) {
      expect(e).toBeInstanceOf(Error);
      expect(e.message).toBe('unknown error');
    }
  });
});
//# sourceMappingURL=api.test.js.map