/**
 * @jest-environment jsdom
 */

import YieldXyz from './yieldxyz'
import Mpc from '../../mpc'
import portalMock from '../../__mocks/portal/portal'
import {
  mockHost,
  mockYieldXyzGetYieldsRequest,
  mockYieldXyzGetYieldsResponse,
  mockYieldXyzEnterRequest,
  mockYieldXyzEnterResponse,
  mockYieldXyzExitRequest,
  mockYieldXyzExitResponse,
  mockYieldXyzGetBalancesRequest,
  mockYieldXyzGetBalancesResponse,
  mockYieldXyzGetHistoricalActionsRequest,
  mockYieldXyzGetHistoricalActionsResponse,
  mockYieldXyzManageYieldRequest,
  mockYieldXyzManageYieldResponse,
  mockYieldXyzTrackTransactionRequest,
  mockYieldXyzTrackTransactionResponse,
  mockYieldXyzGetTransactionResponse,
} from '../../__mocks/constants'

describe('YieldXyz', () => {
  let yieldXyz: YieldXyz
  let mpc: Mpc

  beforeEach(() => {
    jest.clearAllMocks()

    portalMock.host = mockHost
    mpc = new Mpc({
      portal: portalMock,
    })

    yieldXyz = new YieldXyz({ mpc })
  })

  describe('discover', () => {
    it('should call mpc.getYieldXyzYields with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'getYieldXyzYields')
        .mockResolvedValue(mockYieldXyzGetYieldsResponse)

      const result = await yieldXyz.discover(mockYieldXyzGetYieldsRequest)

      expect(spy).toHaveBeenCalledWith(mockYieldXyzGetYieldsRequest)
      expect(result).toEqual(mockYieldXyzGetYieldsResponse)
    })

    it('should propagate errors from mpc.getYieldXyzYields', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'getYieldXyzYields').mockRejectedValue(error)

      await expect(
        yieldXyz.discover(mockYieldXyzGetYieldsRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('enter', () => {
    it('should call mpc.enterYieldXyzYield with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'enterYieldXyzYield')
        .mockResolvedValue(mockYieldXyzEnterResponse)

      const result = await yieldXyz.enter(mockYieldXyzEnterRequest)

      expect(spy).toHaveBeenCalledWith(mockYieldXyzEnterRequest)
      expect(result).toEqual(mockYieldXyzEnterResponse)
    })

    it('should propagate errors from mpc.enterYieldXyzYield', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'enterYieldXyzYield').mockRejectedValue(error)

      await expect(yieldXyz.enter(mockYieldXyzEnterRequest)).rejects.toThrow(
        'Test error',
      )
    })
  })

  describe('exit', () => {
    it('should call mpc.exitYieldXyzYield with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'exitYieldXyzYield')
        .mockResolvedValue(mockYieldXyzExitResponse)

      const result = await yieldXyz.exit(mockYieldXyzExitRequest)

      expect(spy).toHaveBeenCalledWith(mockYieldXyzExitRequest)
      expect(result).toEqual(mockYieldXyzExitResponse)
    })

    it('should propagate errors from mpc.exitYieldXyzYield', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'exitYieldXyzYield').mockRejectedValue(error)

      await expect(yieldXyz.exit(mockYieldXyzExitRequest)).rejects.toThrow(
        'Test error',
      )
    })
  })

  describe('getBalances', () => {
    it('should call mpc.getYieldXyzBalances with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'getYieldXyzBalances')
        .mockResolvedValue(mockYieldXyzGetBalancesResponse)

      const result = await yieldXyz.getBalances(mockYieldXyzGetBalancesRequest)

      expect(spy).toHaveBeenCalledWith(mockYieldXyzGetBalancesRequest)
      expect(result).toEqual(mockYieldXyzGetBalancesResponse)
    })

    it('should propagate errors from mpc.getYieldXyzBalances', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'getYieldXyzBalances').mockRejectedValue(error)

      await expect(
        yieldXyz.getBalances(mockYieldXyzGetBalancesRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('getHistoricalActions', () => {
    it('should call mpc.getYieldXyzHistoricalActions with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'getYieldXyzHistoricalActions')
        .mockResolvedValue(mockYieldXyzGetHistoricalActionsResponse)

      const result = await yieldXyz.getHistoricalActions(
        mockYieldXyzGetHistoricalActionsRequest,
      )

      expect(spy).toHaveBeenCalledWith(mockYieldXyzGetHistoricalActionsRequest)
      expect(result).toEqual(mockYieldXyzGetHistoricalActionsResponse)
    })

    it('should propagate errors from mpc.getYieldXyzHistoricalActions', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'getYieldXyzHistoricalActions').mockRejectedValue(error)

      await expect(
        yieldXyz.getHistoricalActions(mockYieldXyzGetHistoricalActionsRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('manage', () => {
    it('should call mpc.manageYieldXyzYield with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'manageYieldXyzYield')
        .mockResolvedValue(mockYieldXyzManageYieldResponse)

      const result = await yieldXyz.manage(mockYieldXyzManageYieldRequest)

      expect(spy).toHaveBeenCalledWith(mockYieldXyzManageYieldRequest)
      expect(result).toEqual(mockYieldXyzManageYieldResponse)
    })

    it('should propagate errors from mpc.manageYieldXyzYield', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'manageYieldXyzYield').mockRejectedValue(error)

      await expect(
        yieldXyz.manage(mockYieldXyzManageYieldRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('track', () => {
    it('should call mpc.trackYieldXyzTransaction with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'trackYieldXyzTransaction')
        .mockResolvedValue(mockYieldXyzTrackTransactionResponse)

      const result = await yieldXyz.track(mockYieldXyzTrackTransactionRequest)

      expect(spy).toHaveBeenCalledWith(mockYieldXyzTrackTransactionRequest)
      expect(result).toEqual(mockYieldXyzTrackTransactionResponse)
    })

    it('should propagate errors from mpc.trackYieldXyzTransaction', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'trackYieldXyzTransaction').mockRejectedValue(error)

      await expect(
        yieldXyz.track(mockYieldXyzTrackTransactionRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('getTransaction', () => {
    it('should call mpc.getYieldXyzTransaction with the correct arguments', async () => {
      const transactionId = 'test-tx-id'
      const spy = jest
        .spyOn(mpc, 'getYieldXyzTransaction')
        .mockResolvedValue(mockYieldXyzGetTransactionResponse)

      const result = await yieldXyz.getTransaction(transactionId)

      expect(spy).toHaveBeenCalledWith(transactionId)
      expect(result).toEqual(mockYieldXyzGetTransactionResponse)
    })

    it('should propagate errors from mpc.getYieldXyzTransaction', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'getYieldXyzTransaction').mockRejectedValue(error)

      await expect(yieldXyz.getTransaction('test-tx-id')).rejects.toThrow(
        'Test error',
      )
    })
  })
})