|
|
import * as ExperimentAssignments from '../experiment-assignments'; |
|
|
import localStorage from '../local-storage'; |
|
|
import * as Requests from '../requests'; |
|
|
import { delayedValue, ONE_DELAY, validExperimentAssignment } from '../test-common'; |
|
|
import * as Timing from '../timing'; |
|
|
import type { Config, ExperimentAssignment } from '../../types'; |
|
|
|
|
|
const spiedMonotonicNow = jest.spyOn( Timing, 'monotonicNow' ); |
|
|
|
|
|
const mockedFetchExperimentAssignment = jest.fn(); |
|
|
const mockedGetAnonId = jest.fn(); |
|
|
const mockedConfig: Config = { |
|
|
fetchExperimentAssignment: mockedFetchExperimentAssignment, |
|
|
getAnonId: mockedGetAnonId, |
|
|
logError: async () => { |
|
|
throw new Error( 'The tested file should throw and not log.' ); |
|
|
}, |
|
|
isDevelopmentMode: false, |
|
|
}; |
|
|
|
|
|
function mockFetchExperimentAssignmentToMatchExperimentAssignment( |
|
|
experimentAssignment: ExperimentAssignment |
|
|
) { |
|
|
spiedMonotonicNow.mockImplementationOnce( () => experimentAssignment.retrievedTimestamp ); |
|
|
mockedFetchExperimentAssignment.mockImplementationOnce( () => |
|
|
delayedValue( |
|
|
{ |
|
|
ttl: experimentAssignment.ttl, |
|
|
variations: { |
|
|
[ experimentAssignment.experimentName ]: experimentAssignment.variationName, |
|
|
}, |
|
|
}, |
|
|
ONE_DELAY |
|
|
) |
|
|
); |
|
|
} |
|
|
|
|
|
beforeEach( () => { |
|
|
localStorage.clear(); |
|
|
} ); |
|
|
|
|
|
describe( 'fetchExperimentAssignment', () => { |
|
|
it( 'should successfully fetch and return a well formed response with an anonId', async () => { |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( 'asdf', ONE_DELAY ) ); |
|
|
mockFetchExperimentAssignmentToMatchExperimentAssignment( validExperimentAssignment ); |
|
|
const experimentAssignmentWithAnonId = await Requests.fetchExperimentAssignment( |
|
|
mockedConfig, |
|
|
validExperimentAssignment.experimentName |
|
|
); |
|
|
expect( experimentAssignmentWithAnonId ).toEqual( validExperimentAssignment ); |
|
|
expect( mockedFetchExperimentAssignment.mock.calls ).toEqual( [ |
|
|
[ |
|
|
{ |
|
|
anonId: 'asdf', |
|
|
experimentName: 'experiment_name_a', |
|
|
}, |
|
|
], |
|
|
] ); |
|
|
} ); |
|
|
|
|
|
it( 'should successfully fetch and return a well formed response without an anonId', async () => { |
|
|
mockedFetchExperimentAssignment.mockReset(); |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( null, ONE_DELAY ) ); |
|
|
mockFetchExperimentAssignmentToMatchExperimentAssignment( validExperimentAssignment ); |
|
|
const experimentAssignmentWithoutAnonId = await Requests.fetchExperimentAssignment( |
|
|
mockedConfig, |
|
|
validExperimentAssignment.experimentName |
|
|
); |
|
|
|
|
|
expect( experimentAssignmentWithoutAnonId ).toEqual( validExperimentAssignment ); |
|
|
expect( mockedFetchExperimentAssignment.mock.calls ).toEqual( [ |
|
|
[ |
|
|
{ |
|
|
anonId: null, |
|
|
experimentName: 'experiment_name_a', |
|
|
}, |
|
|
], |
|
|
] ); |
|
|
} ); |
|
|
|
|
|
it( 'should return an experiment assignment with a ttl as the maximum of the ttl provided from the server and the set minimum ttl', async () => { |
|
|
const outputTtl = async ( inputTtl: number ) => { |
|
|
mockedFetchExperimentAssignment.mockReset(); |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( null, ONE_DELAY ) ); |
|
|
mockFetchExperimentAssignmentToMatchExperimentAssignment( { |
|
|
...validExperimentAssignment, |
|
|
ttl: inputTtl, |
|
|
} ); |
|
|
const { ttl } = await Requests.fetchExperimentAssignment( |
|
|
mockedConfig, |
|
|
validExperimentAssignment.experimentName |
|
|
); |
|
|
return ttl; |
|
|
}; |
|
|
|
|
|
await expect( outputTtl( ExperimentAssignments.minimumTtl - 1 ) ).resolves.toBe( |
|
|
ExperimentAssignments.minimumTtl |
|
|
); |
|
|
await expect( outputTtl( ExperimentAssignments.minimumTtl ) ).resolves.toBe( |
|
|
ExperimentAssignments.minimumTtl |
|
|
); |
|
|
await expect( outputTtl( ExperimentAssignments.minimumTtl + 1 ) ).resolves.toBe( |
|
|
ExperimentAssignments.minimumTtl + 1 |
|
|
); |
|
|
await expect( outputTtl( ExperimentAssignments.minimumTtl + 1000 ) ).resolves.toBe( |
|
|
ExperimentAssignments.minimumTtl + 1000 |
|
|
); |
|
|
} ); |
|
|
|
|
|
it( 'should throw for an invalid response', async () => { |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( null, ONE_DELAY ) ); |
|
|
mockedFetchExperimentAssignment.mockImplementationOnce( () => |
|
|
delayedValue( |
|
|
{ |
|
|
ttl: 60, |
|
|
}, |
|
|
ONE_DELAY |
|
|
) |
|
|
); |
|
|
await expect( |
|
|
Requests.fetchExperimentAssignment( mockedConfig, validExperimentAssignment.experimentName ) |
|
|
).rejects.toThrow( 'Invalid FetchExperimentAssignmentResponse' ); |
|
|
} ); |
|
|
|
|
|
it( 'should throw for multiple experiments in the response', async () => { |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( null, ONE_DELAY ) ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => validExperimentAssignment.retrievedTimestamp ); |
|
|
mockedFetchExperimentAssignment.mockImplementationOnce( () => |
|
|
delayedValue( |
|
|
{ |
|
|
ttl: 60, |
|
|
variations: { |
|
|
[ validExperimentAssignment.experimentName ]: validExperimentAssignment.variationName, |
|
|
[ validExperimentAssignment.experimentName + '_repeat' ]: |
|
|
validExperimentAssignment.variationName, |
|
|
}, |
|
|
}, |
|
|
ONE_DELAY |
|
|
) |
|
|
); |
|
|
await expect( |
|
|
Requests.fetchExperimentAssignment( mockedConfig, validExperimentAssignment.experimentName ) |
|
|
).rejects.toThrow( |
|
|
'Received multiple experiment assignments while trying to fetch exactly one.' |
|
|
); |
|
|
} ); |
|
|
|
|
|
it( 'should return a fallbackExperimentAssignment for no experiments in the response', async () => { |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( null, ONE_DELAY ) ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => validExperimentAssignment.retrievedTimestamp ); |
|
|
spiedMonotonicNow.mockImplementationOnce( |
|
|
() => validExperimentAssignment.retrievedTimestamp + 1000 |
|
|
); |
|
|
mockedFetchExperimentAssignment.mockImplementationOnce( () => |
|
|
delayedValue( |
|
|
{ |
|
|
ttl: 60, |
|
|
variations: {}, |
|
|
}, |
|
|
ONE_DELAY |
|
|
) |
|
|
); |
|
|
await expect( |
|
|
Requests.fetchExperimentAssignment( mockedConfig, validExperimentAssignment.experimentName ) |
|
|
).resolves.toEqual( { |
|
|
experimentName: 'experiment_name_a', |
|
|
variationName: null, |
|
|
retrievedTimestamp: validExperimentAssignment.retrievedTimestamp + 1000, |
|
|
ttl: 60, |
|
|
isFallbackExperimentAssignment: true, |
|
|
} ); |
|
|
} ); |
|
|
|
|
|
it( 'should throw for response experiment not matching the requested name', async () => { |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( null, ONE_DELAY ) ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => validExperimentAssignment.retrievedTimestamp ); |
|
|
mockFetchExperimentAssignmentToMatchExperimentAssignment( validExperimentAssignment ); |
|
|
await expect( |
|
|
Requests.fetchExperimentAssignment( |
|
|
mockedConfig, |
|
|
validExperimentAssignment.experimentName + '_different_name' |
|
|
) |
|
|
).rejects.toThrow( |
|
|
"Newly fetched ExperimentAssignment's experiment name does not match request." |
|
|
); |
|
|
} ); |
|
|
|
|
|
it( 'should throw for returned experiment not being alive', async () => { |
|
|
jest.spyOn( ExperimentAssignments, 'isAlive' ).mockImplementationOnce( () => false ); |
|
|
mockedGetAnonId.mockImplementationOnce( () => delayedValue( null, ONE_DELAY ) ); |
|
|
mockFetchExperimentAssignmentToMatchExperimentAssignment( validExperimentAssignment ); |
|
|
await expect( |
|
|
Requests.fetchExperimentAssignment( mockedConfig, validExperimentAssignment.experimentName ) |
|
|
).rejects.toThrow( "Newly fetched experiment isn't alive." ); |
|
|
} ); |
|
|
} ); |
|
|
|
|
|
describe( 'isFetchExperimentAssignmentResponse', () => { |
|
|
it( 'should return true for valid responses', () => { |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 1, |
|
|
variations: {}, |
|
|
} ) |
|
|
).toBe( true ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 60, |
|
|
variations: { |
|
|
experiment_a: 'variation_name_a', |
|
|
experiment_b: null, |
|
|
}, |
|
|
} ) |
|
|
).toBe( true ); |
|
|
} ); |
|
|
|
|
|
it( 'should return false for responses with 0 ttl', () => { |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 0, |
|
|
variations: {}, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 0, |
|
|
variations: { |
|
|
experiment_a: 'variation_name_a', |
|
|
experiment_b: null, |
|
|
}, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
} ); |
|
|
|
|
|
it( 'should return false for invalid responses', () => { |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 0, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
variations: {}, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: null, |
|
|
variations: {}, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: undefined, |
|
|
variations: {}, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 'string', |
|
|
variations: {}, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: {}, |
|
|
variations: {}, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 0, |
|
|
variations: null, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 0, |
|
|
variations: undefined, |
|
|
} ) |
|
|
).toBe( false ); |
|
|
expect( |
|
|
Requests.isFetchExperimentAssignmentResponse( { |
|
|
ttl: 0, |
|
|
variations: 'string', |
|
|
} ) |
|
|
).toBe( false ); |
|
|
} ); |
|
|
} ); |
|
|
|
|
|
describe( 'localStorageCachedGetAnonId', () => { |
|
|
it( 'should return a fresh anonId for non-falsy values', async () => { |
|
|
const mockGetAnonIdA = jest.fn( async () => 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdA ) ).toBe( 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdA ) ).toBe( 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdA ) ).toBe( 'asdf' ); |
|
|
expect( mockGetAnonIdA ).toHaveBeenCalledTimes( 3 ); |
|
|
|
|
|
const mockGetAnonIdB = jest.fn( async () => 'qwer' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdB ) ).toBe( 'qwer' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdB ) ).toBe( 'qwer' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdB ) ).toBe( 'qwer' ); |
|
|
expect( mockGetAnonIdB ).toHaveBeenCalledTimes( 3 ); |
|
|
} ); |
|
|
|
|
|
it( 'should not cache an anonId for falsy values', async () => { |
|
|
const mockGetAnonIdNull = jest.fn( async () => null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
expect( mockGetAnonIdNull ).toHaveBeenCalledTimes( 3 ); |
|
|
|
|
|
const mockGetAnonIdEmpty = jest.fn( async () => '' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdEmpty ) ).toBe( null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdEmpty ) ).toBe( null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdEmpty ) ).toBe( null ); |
|
|
expect( mockGetAnonIdEmpty ).toHaveBeenCalledTimes( 3 ); |
|
|
|
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
expect( mockGetAnonIdNull ).toHaveBeenCalledTimes( 6 ); |
|
|
} ); |
|
|
|
|
|
it( 'should return a cached anonId for falsy-values within the expiry time', async () => { |
|
|
const mockGetAnonIdA = jest.fn( async () => 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdA ) ).toBe( 'asdf' ); |
|
|
|
|
|
const mockGetAnonIdNull = jest.fn( async () => null ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( 'asdf' ); |
|
|
expect( mockGetAnonIdNull ).toHaveBeenCalledTimes( 3 ); |
|
|
|
|
|
const mockGetAnonIdEmpty = jest.fn( async () => '' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdEmpty ) ).toBe( 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdEmpty ) ).toBe( 'asdf' ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdEmpty ) ).toBe( 'asdf' ); |
|
|
expect( mockGetAnonIdEmpty ).toHaveBeenCalledTimes( 3 ); |
|
|
} ); |
|
|
|
|
|
it( 'should not return the cached anonId for falsy-values outside of the expiry time', async () => { |
|
|
const mockGetAnonIdA = jest.fn( async () => 'asdf' ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 0 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdA ) ).toBe( 'asdf' ); |
|
|
|
|
|
const mockGetAnonIdNull = jest.fn( async () => null ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 1 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( 'asdf' ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 24 * 60 * 60 * 1000 - 1 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( 'asdf' ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 24 * 60 * 60 * 1000 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 24 * 60 * 60 * 1000 + 1 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => Infinity ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
|
|
|
|
|
|
spiedMonotonicNow.mockImplementationOnce( () => 0 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdA ) ).toBe( 'asdf' ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 1 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( 'asdf' ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 24 * 60 * 60 * 1000 - 1 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( 'asdf' ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 24 * 60 * 60 * 1000 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => 24 * 60 * 60 * 1000 + 1 ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
spiedMonotonicNow.mockImplementationOnce( () => Infinity ); |
|
|
expect( await Requests.localStorageCachedGetAnonId( mockGetAnonIdNull ) ).toBe( null ); |
|
|
} ); |
|
|
} ); |
|
|
|
