import { datatype } from 'faker'
import { sample } from 'lodash'

import { BioimpedanceWithWeight } from '../models/bioimpedance-with-weight.model'
import { Competition, CompetitionCategories, CompetitionCompetitor } from '../../../models/ranking/competition'
import { CompetitionHistoryRepository } from '../../../repositories/ranking/competition/history.repository'
import { MockedModule } from '../../../../test/types'
import { RequiredArgumentError, UnprocessableEntityError } from '../../../errors'

import { CompetitionHistoryFactory } from './competition-history.factory'

describe('CompetitionHistoryFactory', () => {
  describe('#build', () => {
    const competition = Competition.toInstance({})
    const competitor = CompetitionCompetitor.toInstance({})
    const bioimpedance = BioimpedanceWithWeight.toInstance({ done_at: new Date() })
    let competitionHistoryRepository: MockedModule<CompetitionHistoryRepository>

    beforeAll(() => {
      competitionHistoryRepository = {
        create: jest.fn(),
      }
    })

    describe('when bioimpedance is not given', () => {
      it('throws an error', async () => {
        await expect(
          CompetitionHistoryFactory.build({
            competition,
            competitor,
            competitionHistoryRepository: competitionHistoryRepository as any,
            bioimpedance: null,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when compositionHistoryRepository is not given', () => {
      it('throws an error', async () => {
        await expect(
          CompetitionHistoryFactory.build({
            competition,
            competitor,
            competitionHistoryRepository: null,
            bioimpedance,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when competitor has not an id', () => {
      beforeAll(() => {
        competitor.id = null
      })

      it('throws an error', async () => {
        await expect(
          CompetitionHistoryFactory.build({
            competition,
            competitor,
            competitionHistoryRepository: competitionHistoryRepository as any,
            bioimpedance,
          }),
        ).rejects.toThrowError(UnprocessableEntityError)
      })
    })

    describe('when all arguments is given', () => {
      beforeAll(() => {
        competition.category = sample(Object.values(CompetitionCategories))
        competitor.id = datatype.uuid()
      })

      it('creates a history data', async () => {
        await expect(
          CompetitionHistoryFactory.build({
            competition,
            competitor,
            competitionHistoryRepository: competitionHistoryRepository as any,
            bioimpedance,
          }),
        ).resolves.toEqual(
          expect.objectContaining({
            competitor_id: competitor.id,
            done_at: bioimpedance.done_at,
            score: expect.any(Number),
            value: expect.any(Number),
          }),
        )
      })
    })
  })
})