import 'jest'
jest.mock('../users/storageService')

import { saveUserToStorage, getUsersFromStorage } from '../users/storageService'

import usersProvider from '../users'
import {
  NotFoundError,
  InternalError,
  WrongInputError,
  AlreadyExists
} from '../../utils/customErrors'

const setFunctionMock = (fn: any, result: any) => {
  fn.mockImplementation(jest.fn(result))
}

beforeEach(() => {
  jest.resetAllMocks()
})

describe('data:', () => {
  describe('users.ts:', () => {
    describe('getUsers():', () => {
      it('gets and returns all users', async done => {
        const bots = [{ id: 'test' }]
        setFunctionMock(getUsersFromStorage, () => bots)

        const res = await usersProvider.getUsers()

        expect(res).toEqual(bots)
        expect(usersProvider.getUsers).not.toThrowError()
        done()
      })

      it('fails retrieving user and throws InternalError', async done => {
        setFunctionMock(getUsersFromStorage, () => {
          throw new Error('test error')
        })

        try {
          await usersProvider.getUsers()
          expect(false).toBe(true) // fail if doesnt throw Error
        } catch (err) {
          expect(err).toMatchObject(new NotFoundError('Error: test error'))
          expect(getUsersFromStorage).toThrowError(Error)
          done()
        }
      })
    })

    describe('postUser():', () => {
      it('saves user and returns that user', async done => {
        const req: any = {
          body: { user: { email: 'roll@test.com', name: 'testificate', role: 'roll' } }
        }
        setFunctionMock(saveUserToStorage, () => Promise.resolve(req.body.user))

        try {
          const res = await usersProvider.postUser(req)

          expect(res).toEqual(req.body.user)
          expect(saveUserToStorage).toBeCalledWith(req.body.user)
          expect(usersProvider.postUser).not.toThrowError()
        } catch (err) {
          expect(true).toBe(false)
        }

        done()
      })

      it('fails saving user and throws AlreadyExists error', async done => {
        const req: any = {
          body: { user: { email: 'roll@test.com', name: 'testificate', role: 'roll' } }
        }
        setFunctionMock(saveUserToStorage, () => {
          throw 'test error'
        })

        try {
          const res = await usersProvider.postUser(req)
          expect(true).toBe(false)
        } catch (err) {
          expect(saveUserToStorage).toBeCalledWith(req.body.user)
          expect(saveUserToStorage).toThrow('test error')
          expect(err).toMatchObject(new AlreadyExists('test error'))
        }

        done()
      })

      it('fails saving user and throws InternalError', async done => {
        const req: any = {
          body: { user: { email: 'roll@test.com', name: 'testificate', role: 'roll' } }
        }
        setFunctionMock(saveUserToStorage, () => {
          throw new Error('test error')
        })

        try {
          const res = await usersProvider.postUser(req)
          expect(true).toBe(false)
        } catch (err) {
          expect(saveUserToStorage).toBeCalledWith(req.body.user)
          expect(saveUserToStorage).toThrowError(Error)
          expect(err).toMatchObject(new InternalError('test error'))
        }

        done()
      })

      it('throws WrongInputError because wrong input (no version)', async done => {
        const req: any = { body: { bot: {} } }
        setFunctionMock(saveUserToStorage, () => Promise.resolve())

        try {
          await usersProvider.postUser(req)
          expect(true).toBe(false)
        } catch (err) {
          expect(saveUserToStorage).not.toBeCalled()
          expect(err).toMatchObject(new WrongInputError('request body doesnt have parameter user'))
          done()
        }

        done()
      })

      it('throws WrongInputError because wrong input (no bot)', async done => {
        const req: any = {
          body: { user: { email: 'roll@test.com', name: 'testificate', role: undefined } }
        }
        setFunctionMock(saveUserToStorage, () => Promise.resolve())

        try {
          await usersProvider.postUser(req)
          expect(true).toBe(false)
        } catch (err) {
          expect(saveUserToStorage).not.toBeCalled()
          expect(err).toMatchObject(
            new WrongInputError('email, name and/or role were not found in user body')
          )
          done()
        }

        done()
      })
    })
  })
})