@yoroi/claim/lib/commonjs/manager.test.js

The Claim (proof-of-onboarding) package of Yoroi SDK

"use strict";

var _common = require("@yoroi/common");
var _portfolio = require("@yoroi/portfolio");
var _types = require("@yoroi/types");
var _manager = require("./manager");
var _apiFaucet = require("./api-faucet.mocks");
var _manager2 = require("./manager.mocks");
describe('claimManagerMaker', () => {
  const options = {
    address: 'addr_test',
    primaryTokenInfo: _portfolio.tokenInfoMocks.primaryETH,
    tokenManager: {}
  };
  it('success', () => {
    const manager = (0, _manager.claimManagerMaker)(options);
    expect(manager).toBeDefined();
    const managerWithFetcher = (0, _manager.claimManagerMaker)(options, {
      request: _common.fetchData
    });
    expect(managerWithFetcher).toBeDefined();
  });
});
describe('claimManagerMaker - postClaimTokens', () => {
  afterEach(() => {
    jest.clearAllMocks();
  });
  const tokenManagerMock = (0, _portfolio.createTokenManagerMock)();
  tokenManagerMock.sync.mockResolvedValue(new Map([[_portfolio.tokenMocks.nftCryptoKitty.info.id, (0, _common.cacheRecordMaker)({
    expires: Date.now() + 3_600_000,
    hash: 'hash3'
  }, _portfolio.tokenMocks.nftCryptoKitty.info)], [_portfolio.tokenMocks.rnftWhatever.info.id, (0, _common.cacheRecordMaker)({
    expires: Date.now() + 3_600_000,
    hash: 'hash3'
  }, _portfolio.tokenMocks.rnftWhatever.info)]]));
  const options = {
    address: 'addr_test',
    primaryTokenInfo: _portfolio.tokenInfoMocks.primaryETH,
    tokenManager: tokenManagerMock
  };
  const claimAction = {
    action: 'claim',
    code: 'claim_code',
    params: {
      someParam: 'value'
    },
    url: 'https://api.example.com/claim'
  };
  it('should handle successful claim', async () => {
    const mockResponse = {
      tag: 'right',
      value: {
        status: _types.Api.HttpStatusCode.Ok,
        data: _apiFaucet.claimFaucetResponses.claimTokens.success.accepted
      }
    };
    const request = jest.fn().mockResolvedValue(mockResponse);
    const manager = (0, _manager.claimManagerMaker)(options, {
      request
    });
    const result = await manager.claimTokens(claimAction);
    expect(result).toEqual(_manager2.claimApiMockResponses.claimTokens.accepted);
  });
  it('should throw API when not specific to claim', async () => {
    const errorApiResponse = {
      status: _types.Api.HttpStatusCode.Unauthorized,
      message: 'Unauthorized',
      responseData: null
    };
    const mockErrorResponse = {
      tag: 'left',
      error: errorApiResponse
    };
    const request = jest.fn().mockResolvedValue(mockErrorResponse);
    const manager = (0, _manager.claimManagerMaker)(options, {
      request
    });
    await expect(() => manager.claimTokens(claimAction)).rejects.toThrow(_types.Api.Errors.Unauthorized);
  });
  it('should handle malformed API response', async () => {
    const malformedResponse = {
      tag: 'right',
      value: {
        status: _types.Api.HttpStatusCode.Ok,
        data: {
          something: 'else'
        }
      }
    };
    const request = jest.fn().mockResolvedValue(malformedResponse);
    const manager = (0, _manager.claimManagerMaker)(options, {
      request
    });
    await expect(manager.claimTokens(claimAction)).rejects.toThrow(_types.Api.Errors.ResponseMalformed);
  });
  it('should handle unknown errors', async () => {
    const request = async () => {
      throw new _types.Api.Errors.Forbidden();
    };
    const manager = (0, _manager.claimManagerMaker)(options, {
      request
    });
    await expect(manager.claimTokens(claimAction)).rejects.toThrow(_types.Api.Errors.Forbidden);
  });
});
//# sourceMappingURL=manager.test.js.map