initialization.service.spec.ts

import { QueryResult } from 'cozy-client'
import { DateTime } from 'luxon'
import { UserChallenge } from 'models'
import InitializationService from './initialization.service'
import mockClient from '../../tests/__mocks__/client'

import ecogestureData from 'db/ecogestureData.json'
import challengeEntityData from 'db/challengeEntity.json'
import duelEntityData from 'db/duelEntity.json'
import quizEntityData from 'db/quizEntity.json'
import explorationEntityData from 'db/explorationEntity.json'
import fluidPrices from 'db/fluidPrices.json'

import { hashFile } from 'utils/hash'
import { getActualAnalysisDate } from 'utils/date'
import { FluidType } from 'enum/fluid.enum'
import { ecogesturesData } from '../../tests/__mocks__/ecogesturesData.mock'
import { profileData } from '../../tests/__mocks__/profile.mock'
import { fluidStatusData } from '../../tests/__mocks__/fluidStatusData.mock'
import { userChallengeData } from '../../tests/__mocks__/userChallengeData.mock'
import { graphData } from '../../tests/__mocks__/datachartData.mock'
import { allChallengeEntityData } from '../../tests/__mocks__/challengeEntity.mock'
import { allDuelEntity } from '../../tests/__mocks__/duelData.mock'
import { allQuizEntities } from '../../tests/__mocks__/quizData.mock'
import { allExplorationEntities } from '../../tests/__mocks__/explorationData.mock'
import { fluidPrices as allFluidPrices } from '../../tests/__mocks__/fluidPrice.mock'
import {
  mockOutdatedTerm,
  mockUpToDateTerm,
} from '../../tests/__mocks__/termsData.mock'

const mockCreateIndexKonnector = jest.fn()
jest.mock('./konnector.service', () => {
  return jest.fn(() => {
    return {
      createIndexKonnector: mockCreateIndexKonnector,
    }
  })
})

const mockCreateIndexAccount = jest.fn()
jest.mock('./account.service', () => {
  return jest.fn(() => {
    return {
      createIndexAccount: mockCreateIndexAccount,
    }
  })
})

const mockGetProfile = jest.fn()
const mockUpdateProfile = jest.fn()
jest.mock('./profile.service', () => {
  return jest.fn(() => {
    return {
      getProfile: mockGetProfile,
      updateProfile: mockUpdateProfile,
    }
  })
})

const mockGetAllEcogestures = jest.fn()
const mockDeleteAllEcogestures = jest.fn()
jest.mock('./ecogesture.service', () => {
  return jest.fn(() => {
    return {
      getAllEcogestures: mockGetAllEcogestures,
      deleteAllEcogestures: mockDeleteAllEcogestures,
    }
  })
})

const mockGetAllChallengeEntities = jest.fn()
const mockDeleteAllChallengeEntities = jest.fn()
const mockBuildUserChallengeList = jest.fn()
const mockGetUserChallengeDataload = jest.fn()
const mockUserChallengeUpdateFlag = jest.fn()
jest.mock('./challenge.service', () => {
  return jest.fn(() => {
    return {
      getAllChallengeEntities: mockGetAllChallengeEntities,
      deleteAllChallengeEntities: mockDeleteAllChallengeEntities,
      buildUserChallengeList: mockBuildUserChallengeList,
      getUserChallengeDataload: mockGetUserChallengeDataload,
      updateUserChallenge: mockUserChallengeUpdateFlag,
    }
  })
})

const mockGetAllPrices = jest.fn()
const mockDeleteAllFluidsPrices = jest.fn()
jest.mock('./fluidsPrices.service', () => {
  return jest.fn(() => {
    return {
      getAllPrices: mockGetAllPrices,
      deleteAllFluidsPrices: mockDeleteAllFluidsPrices,
    }
  })
})

const mockGetAllDuelEntities = jest.fn()
const mockDeleteAllDuelEntities = jest.fn()
jest.mock('./duel.service', () => {
  return jest.fn(() => {
    return {
      getAllDuelEntities: mockGetAllDuelEntities,
      deleteAllDuelEntities: mockDeleteAllDuelEntities,
    }
  })
})

const mockGetAllQuizEntities = jest.fn()
const mockDeleteAllQuizEntities = jest.fn()
jest.mock('./quiz.service', () => {
  return jest.fn(() => {
    return {
      getAllQuizEntities: mockGetAllQuizEntities,
      deleteAllQuizEntities: mockDeleteAllQuizEntities,
    }
  })
})

const mockGetAllExplorationEntities = jest.fn()
const mockDeleteAllExplorationEntities = jest.fn()
jest.mock('./exploration.service', () => {
  return jest.fn(() => {
    return {
      getAllExplorationEntities: mockGetAllExplorationEntities,
      deleteAllExplorationEntities: mockDeleteAllExplorationEntities,
    }
  })
})

const mockGetKonnectorAccountStatus = jest.fn()
jest.mock('./konnectorStatus.service', () => {
  return jest.fn(() => {
    return {
      getKonnectorAccountStatus: mockGetKonnectorAccountStatus,
    }
  })
})

const mockGetFluidStatus = jest.fn()
jest.mock('./fluid.service', () => {
  return jest.fn(() => {
    return {
      getFluidStatus: mockGetFluidStatus,
    }
  })
})

const mockIsConsentVersionUpToDate = jest.fn()
const mockIsLastTermValidated = jest.fn()
const mockGetTermsVersionType = jest.fn()
const mockGetLastTerm = jest.fn()
jest.mock('./terms.service', () => {
  return jest.fn(() => {
    return {
      isConsentVersionUpToDate: mockIsConsentVersionUpToDate,
      isLastTermValidated: mockIsLastTermValidated,
      getTermsVersionType: mockGetTermsVersionType,
      getLastTerm: mockGetLastTerm,
    }
  })
})

describe('Initialization service', () => {
  const initializationService = new InitializationService(mockClient)
  beforeEach(() => {
    mockClient.query.mockClear()
    mockClient.create.mockClear()
  })

  describe('initIndex method', () => {
    beforeEach(() => {
      mockCreateIndexKonnector.mockClear()
      mockCreateIndexAccount.mockClear()
    })
    it('should return true when all indexes created', async () => {
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.query.mockResolvedValueOnce(mockQueryResult)
      mockCreateIndexKonnector.mockResolvedValueOnce(mockQueryResult)
      mockCreateIndexAccount.mockResolvedValueOnce(mockQueryResult)
      await expect(initializationService.initIndex()).resolves.toBe(true)
    })
    it('should throw error when an index is not created', async () => {
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.query.mockResolvedValueOnce(mockQueryResult)
      mockCreateIndexKonnector.mockRejectedValueOnce(new Error())
      mockCreateIndexAccount.mockResolvedValueOnce(mockQueryResult)
      await expect(initializationService.initIndex()).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initProfile method', () => {
    beforeEach(() => {
      mockGetProfile.mockClear()
      mockUpdateProfile.mockClear()
    })
    it('should return the profil when existing', async () => {
      mockGetProfile.mockResolvedValueOnce(profileData)
      mockUpdateProfile.mockResolvedValueOnce(profileData)
      await expect(initializationService.initProfile()).resolves.toEqual(
        profileData
      )
    })
    it('should create and return the profil when no existing', async () => {
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockGetProfile.mockResolvedValueOnce(null)
      mockClient.create.mockResolvedValueOnce(mockQueryResult)
      mockUpdateProfile.mockResolvedValueOnce(profileData)
      await expect(initializationService.initProfile()).resolves.toEqual(
        profileData
      )
    })
    it('should throw error when the profile is not created', async () => {
      const mockQueryResult: QueryResult<null> = {
        data: null,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockGetProfile.mockResolvedValueOnce(null)
      mockClient.create.mockResolvedValueOnce(mockQueryResult)
      await expect(initializationService.initProfile()).rejects.toThrow(
        new Error('initProfile: Profile not created')
      )
    })
    it('should throw error when the profile could not be fetched', () => {
      mockGetProfile.mockRejectedValueOnce(new Error())
      expect(initializationService.initProfile()).rejects.toEqual(new Error())
    })
    it('should throw error when the profile failed to be created', () => {
      mockGetProfile.mockResolvedValueOnce(null)
      mockClient.create.mockRejectedValueOnce(new Error())
      expect(initializationService.initProfile()).rejects.toEqual(new Error())
    })
  })

  describe('initEcoGesture method', () => {
    beforeEach(() => {
      mockGetAllEcogestures.mockClear()
      mockDeleteAllEcogestures.mockClear()
    })
    it('should return hash when ecogestures hash is already up to date', async () => {
      mockGetAllEcogestures.mockResolvedValueOnce(ecogestureData)
      const hash = hashFile(ecogestureData)
      await expect(initializationService.initEcogesture(hash)).resolves.toEqual(
        hash
      )
    })
    it('should return hash when ecogestures are created', async () => {
      mockGetAllEcogestures
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(ecogestureData)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      const hash = hashFile(ecogestureData)
      await expect(initializationService.initEcogesture(hash)).resolves.toEqual(
        hash
      )
    })
    it('should throw an error when ecogestures should be created and created ecogestures number does not match', async () => {
      mockGetAllEcogestures
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(ecogesturesData)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initEcogesture(hashFile(ecogestureData))
      ).rejects.toThrow(
        new Error(
          'initEcogesture: Created ecogesture type entities does not match'
        )
      )
    })
    it('should throw an error when ecogestures should be created and creation failed', async () => {
      mockGetAllEcogestures.mockResolvedValueOnce(null)
      mockClient.create.mockRejectedValue(new Error())
      await expect(
        initializationService.initEcogesture(hashFile(ecogestureData))
      ).rejects.toThrow(new Error())
    })
    it('should return hash when ecogestures are updated', async () => {
      mockGetAllEcogestures
        .mockResolvedValueOnce(ecogestureData)
        .mockResolvedValueOnce(ecogestureData)
      mockDeleteAllEcogestures.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initEcogesture('')).resolves.toEqual(
        hashFile(ecogestureData)
      )
    })
    it('should throw an error when ecogestures should be updated and created ecogestures number does not match', async () => {
      mockGetAllEcogestures
        .mockResolvedValueOnce(ecogestureData)
        .mockResolvedValueOnce(ecogesturesData)
      mockDeleteAllEcogestures.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initEcogesture('')).rejects.toThrow(
        new Error(
          'initEcogesture: Created ecogesture type entities does not match'
        )
      )
    })
    it('should throw an error when ecogestures should be updated and ecogestures creation failed', async () => {
      mockGetAllEcogestures
        .mockResolvedValueOnce(ecogestureData)
        .mockResolvedValueOnce(ecogestureData)
      mockDeleteAllEcogestures.mockResolvedValue(true)
      mockClient.create.mockRejectedValueOnce(new Error())
      expect(initializationService.initEcogesture('')).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initFluidPrices method', () => {
    beforeEach(() => {
      mockGetAllPrices.mockClear()
      mockDeleteAllFluidsPrices.mockClear()
    })
    it('should return hash when fluidPrices hash is already up to date', async () => {
      mockGetAllPrices.mockResolvedValueOnce(fluidPrices)
      const hash = hashFile(fluidPrices)
      await expect(
        initializationService.initFluidPrices(hash)
      ).resolves.toEqual(hash)
    })
    it('should return hash when fluidPrices are created', async () => {
      mockGetAllPrices
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(fluidPrices)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      const hash = hashFile(fluidPrices)
      await expect(
        initializationService.initFluidPrices(hash)
      ).resolves.toEqual(hash)
    })
    it('should throw an error when fluidPrices entities should be created and created fluidPrices entities number does not match', async () => {
      mockGetAllPrices
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(allFluidPrices)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initFluidPrices(hashFile(fluidPrices))
      ).rejects.toThrow(
        new Error(
          'initFluidPrices: Created fluidPrices type entities does not match'
        )
      )
    })
    it('should throw an error when fluidPrices should be created and creation failed', async () => {
      mockGetAllPrices.mockResolvedValueOnce(null)
      mockClient.create.mockRejectedValue(new Error())
      await expect(
        initializationService.initChallengeEntity(hashFile(fluidPrices))
      ).rejects.toThrow(new Error())
    })
    it('should return hash when fluidPrices are updated', async () => {
      mockGetAllPrices
        .mockResolvedValueOnce(fluidPrices)
        .mockResolvedValueOnce(fluidPrices)
      mockDeleteAllFluidsPrices.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initFluidPrices('')).resolves.toEqual(
        hashFile(fluidPrices)
      )
    })
    it('should throw an error when fluidPrices should be updated and fluidPrices entities number does not match', async () => {
      mockGetAllPrices
        .mockResolvedValueOnce('')
        .mockResolvedValueOnce(allFluidPrices)
      mockDeleteAllFluidsPrices.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initFluidPrices('')).rejects.toThrow(
        new Error(
          'initFluidPrices: Created fluidPrices type entities does not match'
        )
      )
    })
    it('should throw an error whenfluidPrices should be updated and fluidPrices entities creation failed', async () => {
      mockGetAllPrices
        .mockResolvedValueOnce(fluidPrices)
        .mockResolvedValueOnce(fluidPrices)
      mockDeleteAllFluidsPrices.mockResolvedValue(true)
      mockClient.create.mockRejectedValueOnce(new Error())
      expect(initializationService.initFluidPrices('')).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initChallengeEntity method', () => {
    beforeEach(() => {
      mockGetAllChallengeEntities.mockClear()
      mockDeleteAllChallengeEntities.mockClear()
    })
    it('should return hash when challenges hash is already up to date', async () => {
      mockGetAllChallengeEntities.mockResolvedValueOnce(challengeEntityData)
      const hash = hashFile(challengeEntityData)
      await expect(
        initializationService.initChallengeEntity(hash)
      ).resolves.toEqual(hash)
    })
    it('should return hash when challenge entities are created', async () => {
      mockGetAllChallengeEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(challengeEntityData)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      const hash = hashFile(challengeEntityData)
      await expect(
        initializationService.initChallengeEntity(hash)
      ).resolves.toEqual(hash)
    })
    it('should throw an error when challenge entities should be created and created challenge entities number does not match', async () => {
      mockGetAllChallengeEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(allChallengeEntityData)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initChallengeEntity(hashFile(challengeEntityData))
      ).rejects.toThrow(
        new Error(
          'initChallengeEntity: Created challenge entities does not match'
        )
      )
    })
    it('should throw an error when challenge entities should be created and creation failed', async () => {
      mockGetAllChallengeEntities.mockResolvedValueOnce(null)
      mockClient.create.mockRejectedValue(new Error())
      await expect(
        initializationService.initChallengeEntity(hashFile(challengeEntityData))
      ).rejects.toThrow(new Error())
    })
    it('should return hash when challenge entities are updated', async () => {
      mockGetAllChallengeEntities
        .mockResolvedValueOnce(challengeEntityData)
        .mockResolvedValueOnce(challengeEntityData)
      mockDeleteAllChallengeEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initChallengeEntity('')
      ).resolves.toEqual(hashFile(challengeEntityData))
    })
    it('should throw an error when challenge entities should be updated and created challenge entities number does not match', async () => {
      mockGetAllChallengeEntities
        .mockResolvedValueOnce(challengeEntityData)
        .mockResolvedValueOnce(allChallengeEntityData)
      mockDeleteAllChallengeEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initChallengeEntity('')
      ).rejects.toThrow(
        new Error(
          'initChallengeEntity: Created challenge entities does not match'
        )
      )
    })
    it('should throw an error when challenge entities should be updated and challenge entities creation failed', async () => {
      mockGetAllChallengeEntities
        .mockResolvedValueOnce(challengeEntityData)
        .mockResolvedValueOnce(challengeEntityData)
      mockDeleteAllChallengeEntities.mockResolvedValue(true)
      mockClient.create.mockRejectedValueOnce(new Error())
      expect(initializationService.initChallengeEntity('')).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initDuelEntity method', () => {
    beforeEach(() => {
      mockGetAllDuelEntities.mockClear()
      mockDeleteAllDuelEntities.mockClear()
    })
    it('should return hash when duel hash is already up to date', async () => {
      mockGetAllDuelEntities.mockResolvedValueOnce(duelEntityData)
      const hash = hashFile(duelEntityData)
      await expect(initializationService.initDuelEntity(hash)).resolves.toEqual(
        hash
      )
    })
    it('should return hash when duel entities are created', async () => {
      mockGetAllDuelEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(duelEntityData)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      const hash = hashFile(duelEntityData)
      await expect(initializationService.initDuelEntity(hash)).resolves.toEqual(
        hash
      )
    })
    it('should throw an error when duel entities should be created and created duel entities number does not match', async () => {
      mockGetAllDuelEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(allDuelEntity)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initDuelEntity(hashFile(duelEntityData))
      ).rejects.toThrow(
        new Error('initDuelEntity: Created duel entities does not match')
      )
    })
    it('should throw an error when duel entities should be created and creation failed', async () => {
      mockGetAllDuelEntities.mockResolvedValueOnce(null)
      mockClient.create.mockRejectedValue(new Error())
      await expect(
        initializationService.initDuelEntity(hashFile(duelEntityData))
      ).rejects.toThrow(new Error())
    })
    it('should return hash when duel entities are updated', async () => {
      mockGetAllDuelEntities
        .mockResolvedValueOnce(duelEntityData)
        .mockResolvedValueOnce(duelEntityData)
      mockDeleteAllDuelEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initDuelEntity('')).resolves.toEqual(
        hashFile(duelEntityData)
      )
    })
    it('should throw an error when duel entities should be updated and created duel entities number does not match', async () => {
      mockGetAllDuelEntities
        .mockResolvedValueOnce(duelEntityData)
        .mockResolvedValueOnce(allDuelEntity)
      mockDeleteAllDuelEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initDuelEntity('')).rejects.toThrow(
        new Error('initDuelEntity: Created duel entities does not match')
      )
    })
    it('should throw an error when duel entities should be updated and duel entities creation failed', async () => {
      mockGetAllDuelEntities
        .mockResolvedValueOnce(duelEntityData)
        .mockResolvedValueOnce(duelEntityData)
      mockDeleteAllDuelEntities.mockResolvedValue(true)
      mockClient.create.mockRejectedValueOnce(new Error())
      expect(initializationService.initDuelEntity('')).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initQuizEntity method', () => {
    beforeEach(() => {
      mockGetAllQuizEntities.mockClear()
      mockDeleteAllQuizEntities.mockClear()
    })
    it('should return hash when quiz hash is already up to date', async () => {
      mockGetAllQuizEntities.mockResolvedValueOnce(quizEntityData)
      const hash = hashFile(quizEntityData)
      await expect(initializationService.initQuizEntity(hash)).resolves.toEqual(
        hash
      )
    })
    it('should return hash when quiz entities are created', async () => {
      mockGetAllQuizEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(quizEntityData)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      const hash = hashFile(quizEntityData)
      await expect(initializationService.initQuizEntity(hash)).resolves.toEqual(
        hash
      )
    })
    it('should throw an error when quiz entities should be created and created quiz entities number does not match', async () => {
      mockGetAllQuizEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(allQuizEntities)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initQuizEntity(hashFile(quizEntityData))
      ).rejects.toThrow(
        new Error('initQuizEntity: Created quiz entities does not match')
      )
    })
    it('should throw an error when quiz entities should be created and creation failed', async () => {
      mockGetAllQuizEntities.mockResolvedValueOnce(null)
      mockClient.create.mockRejectedValue(new Error())
      await expect(
        initializationService.initQuizEntity(hashFile(quizEntityData))
      ).rejects.toThrow(new Error())
    })
    it('should return hash when quiz entities are updated', async () => {
      mockGetAllQuizEntities
        .mockResolvedValueOnce(quizEntityData)
        .mockResolvedValueOnce(quizEntityData)
      mockDeleteAllQuizEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initQuizEntity('')).resolves.toEqual(
        hashFile(quizEntityData)
      )
    })
    it('should throw an error when quiz entities should be updated and created quiz entities number does not match', async () => {
      mockGetAllQuizEntities
        .mockResolvedValueOnce(quizEntityData)
        .mockResolvedValueOnce(allQuizEntities)
      mockDeleteAllQuizEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(initializationService.initQuizEntity('')).rejects.toThrow(
        new Error('initQuizEntity: Created quiz entities does not match')
      )
    })
    it('should throw an error when quiz entities should be updated and quiz entities creation failed', async () => {
      mockGetAllQuizEntities
        .mockResolvedValueOnce(quizEntityData)
        .mockResolvedValueOnce(quizEntityData)
      mockDeleteAllQuizEntities.mockResolvedValue(true)
      mockClient.create.mockRejectedValueOnce(new Error())
      expect(initializationService.initQuizEntity('')).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initExplorationEntity method', () => {
    beforeEach(() => {
      mockGetAllExplorationEntities.mockClear()
      mockDeleteAllExplorationEntities.mockClear()
    })
    it('should return hash when explorations hash is already up to date', async () => {
      mockGetAllExplorationEntities.mockResolvedValueOnce(explorationEntityData)
      const hash = hashFile(explorationEntityData)
      await expect(
        initializationService.initExplorationEntity(hash)
      ).resolves.toEqual(hash)
    })
    it('should return hash when exploration entities are created', async () => {
      mockGetAllExplorationEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(explorationEntityData)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      const hash = hashFile(explorationEntityData)
      await expect(
        initializationService.initExplorationEntity(hash)
      ).resolves.toEqual(hash)
    })
    it('should throw an error when exploration entities should be created and created exploration entities number does not match', async () => {
      mockGetAllExplorationEntities
        .mockResolvedValueOnce(null)
        .mockResolvedValueOnce(allExplorationEntities)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initExplorationEntity(
          hashFile(explorationEntityData)
        )
      ).rejects.toThrow(
        new Error(
          'initExplorationEntity: Created exploration entities does not match'
        )
      )
    })
    it('should throw an error when exploration entities should be created and creation failed', async () => {
      mockGetAllExplorationEntities.mockResolvedValueOnce(null)
      mockClient.create.mockRejectedValue(new Error())
      await expect(
        initializationService.initExplorationEntity(
          hashFile(explorationEntityData)
        )
      ).rejects.toThrow(new Error())
    })
    it('should return hash when exploration entities are updated', async () => {
      mockGetAllExplorationEntities
        .mockResolvedValueOnce(explorationEntityData)
        .mockResolvedValueOnce(explorationEntityData)
      mockDeleteAllExplorationEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initExplorationEntity('')
      ).resolves.toEqual(hashFile(explorationEntityData))
    })
    it('should throw an error when exploration entities should be updated and created exploration entities number does not match', async () => {
      mockGetAllExplorationEntities
        .mockResolvedValueOnce(explorationEntityData)
        .mockResolvedValueOnce(allExplorationEntities)
      mockDeleteAllExplorationEntities.mockResolvedValue(true)
      const mockQueryResult: QueryResult<boolean> = {
        data: true,
        bookmark: '',
        next: false,
        skip: 0,
      }
      mockClient.create.mockResolvedValue(mockQueryResult)
      await expect(
        initializationService.initExplorationEntity('')
      ).rejects.toThrow(
        new Error(
          'initExplorationEntity: Created exploration entities does not match'
        )
      )
    })
    it('should throw an error when exploration entities should be updated and exploration entities creation failed', async () => {
      mockGetAllExplorationEntities
        .mockResolvedValueOnce(explorationEntityData)
        .mockResolvedValueOnce(explorationEntityData)
      mockDeleteAllExplorationEntities.mockResolvedValue(true)
      mockClient.create.mockRejectedValueOnce(new Error())
      expect(initializationService.initExplorationEntity('')).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initAnalysis method', () => {
    it('should return monthlyAnalysisDate and haveSeenLastAnalysis when analysis is up to date', async () => {
      const mockProfile = {
        ...profileData,
        monthlyAnalysisDate: getActualAnalysisDate(),
      }
      await expect(
        initializationService.initAnalysis(mockProfile)
      ).resolves.toEqual({
        monthlyAnalysisDate: getActualAnalysisDate(),
        haveSeenLastAnalysis: mockProfile.haveSeenLastAnalysis,
      })
    })
    it('should return updated monthlyAnalysisDate and haveSeenLastAnalysis=true when analysis is not up to date and isFirstConnection', async () => {
      const mockProfile = {
        ...profileData,
        monthlyAnalysisDate: DateTime.fromISO('2000-10-02T00:00:00.000Z', {
          zone: 'utc',
        }),
        haveSeenLastAnalysis: true,
      }
      await expect(
        initializationService.initAnalysis(mockProfile)
      ).resolves.toEqual({
        monthlyAnalysisDate: getActualAnalysisDate(),
        haveSeenLastAnalysis: true,
      })
    })
    it('should return updated monthlyAnalysisDate and haveSeenLastAnalysis=false when analysis is not up to date and isFirstConnection is false', async () => {
      const mockProfile = {
        ...profileData,
        isFirstConnection: false,
        monthlyAnalysisDate: DateTime.fromISO('2000-10-02T00:00:00.000Z', {
          zone: 'utc',
        }),
        haveSeenLastAnalysis: true,
      }
      await expect(
        initializationService.initAnalysis(mockProfile)
      ).resolves.toEqual({
        monthlyAnalysisDate: getActualAnalysisDate(),
        haveSeenLastAnalysis: false,
      })
    })
  })

  describe('initFluidType method', () => {
    beforeEach(() => {
      mockGetKonnectorAccountStatus.mockClear()
    })
    it('should return all fluid types', async () => {
      mockGetKonnectorAccountStatus.mockResolvedValueOnce([
        FluidType.ELECTRICITY,
        FluidType.WATER,
        FluidType.GAS,
      ])
      await expect(initializationService.initFluidTypes()).resolves.toEqual([
        FluidType.ELECTRICITY,
        FluidType.WATER,
        FluidType.GAS,
      ])
    })
    it('should throw an error when null is retrieved as fluid types', async () => {
      mockGetKonnectorAccountStatus.mockResolvedValueOnce(null)
      await expect(initializationService.initFluidTypes()).rejects.toThrow(
        new Error('initFluidTypes: FluidTypes not found')
      )
    })
    it('should throw an error when it fails to retrieve the fluid types', async () => {
      mockGetKonnectorAccountStatus.mockRejectedValueOnce(new Error())
      await expect(initializationService.initFluidTypes()).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initFluidStatus method', () => {
    beforeEach(() => {
      mockGetFluidStatus.mockClear()
    })
    it('should return  all fluids type', async () => {
      mockGetFluidStatus.mockResolvedValueOnce(fluidStatusData)
      await expect(initializationService.initFluidStatus()).resolves.toEqual(
        fluidStatusData
      )
    })
    it('should throw an error when null is retrieved as status', async () => {
      mockGetFluidStatus.mockResolvedValueOnce(null)
      await expect(initializationService.initFluidStatus()).rejects.toThrow(
        new Error('initFluidStatus: fluidStatus not found')
      )
    })
    it('should throw an error when it fails to retrieve the status', async () => {
      mockGetFluidStatus.mockRejectedValueOnce(new Error())
      await expect(initializationService.initFluidStatus()).rejects.toThrow(
        new Error()
      )
    })
  })

  describe('initUserChallenges method', () => {
    beforeEach(() => {
      mockBuildUserChallengeList.mockClear()
    })
    it('should return all userChallenges', async () => {
      mockBuildUserChallengeList.mockResolvedValueOnce(userChallengeData)
      await expect(
        initializationService.initUserChallenges([])
      ).resolves.toEqual(userChallengeData)
    })
    it('should throw an error when null is retrieved as status', async () => {
      mockBuildUserChallengeList.mockResolvedValueOnce(null)
      await expect(
        initializationService.initUserChallenges([])
      ).rejects.toThrow(
        new Error('initUserChallenges: userChallengeList not found')
      )
    })
    it('should throw an error when it fails to retrieve the status', async () => {
      mockBuildUserChallengeList.mockRejectedValueOnce(new Error())
      await expect(
        initializationService.initUserChallenges([])
      ).rejects.toThrow(new Error())
    })
  })

  describe('initDuelProgress method', () => {
    beforeEach(() => {
      mockGetUserChallengeDataload.mockClear()
      mockUserChallengeUpdateFlag.mockClear()
    })
    it('should return updatedUserChallenge and dataload ', async () => {
      mockGetUserChallengeDataload.mockResolvedValueOnce(graphData.actualData)
      const expectedUpdatedUserChallenge: UserChallenge = {
        ...userChallengeData[0],
        duel: {
          ...userChallengeData[0].duel,
          userConsumption: 130.83585,
        },
      }
      mockUserChallengeUpdateFlag.mockResolvedValueOnce(
        expectedUpdatedUserChallenge
      )
      const expectedResult = {
        updatedUserChallenge: expectedUpdatedUserChallenge,