Newer
Older
import challengeEntityData from 'db/challengeEntity.json'
import duelEntityData from 'db/duelEntity.json'
import explorationEntityData from 'db/explorationEntity.json'
import quizEntityData from 'db/quizEntity.json'
import { DateTime } from 'luxon'
import { UserChallenge } from 'models'
import { getActualAnalysisDate } from 'utils/date'
import { hashFile } from 'utils/hash'
import { allChallengeEntityData } from '../../tests/__mocks__/challengeEntity.mock'
import { graphData } from '../../tests/__mocks__/chartData.mock'
import mockClient from '../../tests/__mocks__/client'
import { allDuelEntity } from '../../tests/__mocks__/duelData.mock'
import { allExplorationEntities } from '../../tests/__mocks__/explorationData.mock'
import { fluidPrices } from '../../tests/__mocks__/fluidPrice.mock'
import { fluidStatusData } from '../../tests/__mocks__/fluidStatusData.mock'
import { profileData } from '../../tests/__mocks__/profileData.mock'
import { allQuizEntities } from '../../tests/__mocks__/quizData.mock'
import {
mockOutdatedTerm,
mockUpToDateTerm,
} from '../../tests/__mocks__/termsData.mock'
import { userChallengeData } from '../../tests/__mocks__/userChallengeData.mock'
import InitializationService from './initialization.service'
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 mockGetAllChallengeEntities = jest.fn()
const mockDeleteAllChallengeEntities = jest.fn()
const mockBuildUserChallengeList = jest.fn()
const mockGetUserChallengeDataload = jest.fn()
const mockUserChallengeUpdateFlag = jest.fn()
Yoan VALLET
committed
const mockInitChallengeDuelProgress = jest.fn()
jest.mock('./challenge.service', () => {
getAllChallengeEntities: mockGetAllChallengeEntities,
deleteAllChallengeEntities: mockDeleteAllChallengeEntities,
buildUserChallengeList: mockBuildUserChallengeList,
getUserChallengeDataload: mockGetUserChallengeDataload,
updateUserChallenge: mockUserChallengeUpdateFlag,
Yoan VALLET
committed
initChallengeDuelProgress: mockInitChallengeDuelProgress,
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', () => {
getAllDuelEntities: mockGetAllDuelEntities,
deleteAllDuelEntities: mockDeleteAllDuelEntities,
const mockGetAllQuizEntities = jest.fn()
const mockDeleteAllQuizEntities = jest.fn()
jest.mock('./quiz.service', () => {
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
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,
const initializationService = new InitializationService(
mockClient,
jest.fn(),
jest.fn()
)
beforeEach(() => {
mockClient.query.mockClear()
mockClient.create.mockClear()
})
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('initFluidPrices method', () => {
beforeEach(() => {
mockGetAllPrices.mockClear()
mockDeleteAllFluidsPrices.mockClear()
})
it('should do nothing because prices are already created', async () => {
mockGetAllPrices.mockResolvedValueOnce(fluidPrices)
const isDone = await initializationService.initFluidPrices()
expect(isDone).toBeTruthy()
it('should try to fetch prices from remote doctype', async () => {
mockGetAllPrices.mockResolvedValueOnce('')
const isDone = await initializationService.initFluidPrices()
expect(isDone).toBeFalsy()
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(
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)
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',
}),
}
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 () => {
monthlyAnalysisDate: DateTime.fromISO('2000-10-02T00:00:00.000Z', {
zone: 'utc',
}),
}
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 () => {
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', () => {
Yoan VALLET
committed
mockInitChallengeDuelProgress.mockClear()
Yoan VALLET
committed
it('should return updatedUserChallenge and dataload', async () => {
const expectedUpdatedUserChallenge: UserChallenge = {
...userChallengeData[0],
duel: {
...userChallengeData[0].duel,
userConsumption: 130.83585,
},
}
const expectedResult = {
updatedUserChallenge: expectedUpdatedUserChallenge,
dataloads: graphData.actualData,
}
Yoan VALLET
committed
mockInitChallengeDuelProgress.mockResolvedValueOnce(expectedResult)
await expect(
initializationService.initDuelProgress(userChallengeData[0])
).resolves.toEqual(expectedResult)
})
it('should throw an error when it fails to retrieve the status', async () => {
Yoan VALLET
committed
mockInitChallengeDuelProgress.mockRejectedValueOnce(new Error())
await expect(
initializationService.initDuelProgress(userChallengeData[0])
).rejects.toThrow(new Error())
})
})
it('should not show consent page', async () => {
mockIsConsentVersionUpToDate.mockResolvedValueOnce(true)
mockIsLastTermValidated.mockResolvedValueOnce(true)
mockGetLastTerm.mockResolvedValueOnce(mockUpToDateTerm)
await expect(initializationService.initConsent()).resolves.toEqual({
accepted: true,
versionType: 'init',
})
it('should show consent page', async () => {
mockIsConsentVersionUpToDate.mockResolvedValueOnce(false)
mockIsLastTermValidated.mockResolvedValueOnce(false)
mockGetLastTerm.mockResolvedValueOnce(mockOutdatedTerm)
await expect(initializationService.initConsent()).resolves.toEqual({
accepted: false,
versionType: 'major',
})
it('should throw an error when it fails to checks for consent', async () => {
mockIsConsentVersionUpToDate.mockRejectedValueOnce(new Error())
await expect(initializationService.initConsent()).rejects.toThrow(
new Error()
)
})
})