triggers.service.spec.ts

import { QueryResult } from 'cozy-client'
import { Trigger, TriggerState } from 'models'
import { accountsData } from 'tests/__mocks__/accountsData.mock'
import mockClient from 'tests/__mocks__/client.mock'
import { konnectorsData } from 'tests/__mocks__/konnectorsData.mock'
import { getError } from 'tests/__mocks__/testUtils'
import { triggerStateData } from 'tests/__mocks__/triggerStateData.mock'
import { triggersData } from 'tests/__mocks__/triggersData.mock'
import TriggerService from './triggers.service'

const mockCreateTrigger = jest.fn()
jest.mock('cozy-harvest-lib/dist/connections/triggers', () => {
  return jest.fn(() => ({
    createTrigger: mockCreateTrigger,
  }))
})

describe('TriggerService service', () => {
  const triggerService = new TriggerService(mockClient)

  describe('createTrigger method', () => {
    it('should return created Trigger', async () => {
      mockCreateTrigger.mockResolvedValueOnce(triggersData[0])
      const result: Trigger = await triggerService.createTrigger(
        accountsData[0],
        konnectorsData[0]
      )
      expect(result).toEqual(triggersData[0])
    })
  })

  describe('getTrigger method', () => {
    it('should return Trigger', async () => {
      const mockQueryResult: QueryResult<Trigger[]> = {
        data: [triggersData[0]],
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.query.mockResolvedValueOnce(mockQueryResult)
      const result: Trigger | null = await triggerService.getTrigger(
        accountsData[0],
        konnectorsData[0]
      )
      expect(result).toEqual(triggersData[0])
    })

    it('should return null when no trigger found', async () => {
      const mockQueryResult: QueryResult<Trigger[]> = {
        data: [],
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.query.mockResolvedValueOnce(mockQueryResult)
      const result: Trigger | null = await triggerService.getTrigger(
        accountsData[0],
        konnectorsData[0]
      )
      expect(result).toBe(null)
    })
  })

  describe('getTriggerForAccount method', () => {
    it('should return Trigger', async () => {
      const mockQueryResult: QueryResult<Trigger[]> = {
        data: [triggersData[0]],
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.query.mockResolvedValueOnce(mockQueryResult)
      const result: Trigger | null = await triggerService.getTriggerForAccount(
        accountsData[0]
      )
      expect(result).toEqual(triggersData[0])
    })

    it('should return null when no trigger found', async () => {
      const mockQueryResult: QueryResult<Trigger[]> = {
        data: [],
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.query.mockResolvedValueOnce(mockQueryResult)
      const result: Trigger | null = await triggerService.getTriggerForAccount(
        accountsData[0]
      )
      expect(result).toBe(null)
    })
  })

  describe('fetchTriggerState method', () => {
    it('should return Trigger state', async () => {
      const mockResult = {
        data: {
          attributes: {
            // eslint-disable-next-line camelcase
            current_state: triggerStateData,
          },
        },
      }
      mockClient.getStackClient().fetchJSON.mockResolvedValueOnce(mockResult)
      const result: TriggerState | null =
        await triggerService.fetchTriggerState(triggersData[0])
      expect(result).toEqual(triggerStateData)
    })

    it('should return null when current_state is empty', async () => {
      const mockResult = {
        // eslint-disable-next-line camelcase
        data: { attributes: { current_state: null } },
      }
      mockClient.getStackClient().fetchJSON.mockResolvedValueOnce(mockResult)
      const result: TriggerState | null =
        await triggerService.fetchTriggerState(triggersData[0])
      expect(result).toBe(null)
    })

    it('should throw an error', async () => {
      mockClient.getStackClient().fetchJSON.mockRejectedValueOnce(new Error())
      const error = await getError(async () =>
        triggerService.fetchTriggerState(triggersData[0])
      )
      expect(error).toEqual(new Error('Fetch trigger state failed'))
    })
  })

  describe('deleteTrigger method', () => {
    it('should return true when destroy successfully', async () => {
      const mockDestroyResult: QueryResult<Trigger[]> = {
        data: [],
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.destroy.mockResolvedValueOnce(mockDestroyResult)
      const result = await triggerService.deleteTrigger(triggersData[0])
      expect(result).toBe(true)
    })

    it('should throw error when destroy unsuccessfully', async () => {
      mockClient.destroy.mockRejectedValueOnce(new Error())
      const error = await getError(async () =>
        triggerService.deleteTrigger(triggersData[0])
      )
      expect(error).toEqual(new Error('Delete trigger failed'))
    })
  })
})