@openobserve/browser-core 0.3.2 → 0.3.3

package/src/domain/session/sessionStoreOperations.spec.ts

@@ -1,234 +0,0 @@
-import { createFakeSessionStoreStrategy, mockClock } from '../../../test'
-import type { SessionState } from './sessionState'
-import { expandSessionState } from './sessionState'
-import {
-  processSessionStoreOperations,
-  LOCK_MAX_TRIES,
-  LOCK_RETRY_DELAY,
-  createLock,
-  LOCK_EXPIRATION_DELAY,
-} from './sessionStoreOperations'
-
-const EXPIRED_SESSION: SessionState = { isExpired: '1', anonymousId: '0' }
-
-describe('sessionStoreOperations', () => {
-  let initialSession: SessionState
-  let otherSession: SessionState
-  let processSpy: jasmine.Spy<jasmine.Func>
-  let afterSpy: jasmine.Spy<jasmine.Func>
-  const now = Date.now()
-
-  beforeEach(() => {
-    initialSession = { id: '123', created: String(now) }
-    otherSession = { id: '456', created: String(now + 100) }
-    processSpy = jasmine.createSpy('process')
-    afterSpy = jasmine.createSpy('after')
-  })
-
-  describe('with lock access disabled', () => {
-    it('should persist session when process returns a value', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: false, initialSession })
-      processSpy.and.returnValue({ ...otherSession })
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-
-      expect(processSpy).toHaveBeenCalledWith(initialSession)
-      const expectedSession = { ...otherSession, expire: jasmine.any(String) }
-      expect(sessionStoreStrategy.retrieveSession()).toEqual(expectedSession)
-      expect(afterSpy).toHaveBeenCalledWith(expectedSession)
-    })
-
-    it('should clear session when process returns an expired session', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: false, initialSession })
-      processSpy.and.returnValue(EXPIRED_SESSION)
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-
-      expect(processSpy).toHaveBeenCalledWith(initialSession)
-      expect(sessionStoreStrategy.retrieveSession()).toEqual(EXPIRED_SESSION)
-      expect(afterSpy).toHaveBeenCalledWith(EXPIRED_SESSION)
-    })
-
-    it('should not persist session when process returns undefined', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: false, initialSession })
-      processSpy.and.returnValue(undefined)
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-
-      expect(processSpy).toHaveBeenCalledWith(initialSession)
-      expect(sessionStoreStrategy.retrieveSession()).toEqual(initialSession)
-      expect(afterSpy).toHaveBeenCalledWith(initialSession)
-    })
-
-    it('LOCK_MAX_TRIES value should not influence the behavior when lock mechanism is not enabled', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: false, initialSession })
-      processSpy.and.returnValue({ ...otherSession })
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy, LOCK_MAX_TRIES)
-
-      expect(processSpy).toHaveBeenCalledWith(initialSession)
-      const expectedSession = { ...otherSession, expire: jasmine.any(String) }
-      expect(sessionStoreStrategy.retrieveSession()).toEqual(expectedSession)
-      expect(afterSpy).toHaveBeenCalledWith(expectedSession)
-    })
-  })
-
-  describe('with lock access enabled', () => {
-    it('should persist session when process returns a value', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: true, initialSession })
-      processSpy.and.returnValue({ ...otherSession })
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-
-      expect(processSpy).toHaveBeenCalledWith(initialSession)
-      const expectedSession = { ...otherSession, expire: jasmine.any(String) }
-      expect(sessionStoreStrategy.retrieveSession()).toEqual(expectedSession)
-      expect(afterSpy).toHaveBeenCalledWith(expectedSession)
-    })
-
-    it('should clear session when process returns an expired session', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: true, initialSession })
-      processSpy.and.returnValue(EXPIRED_SESSION)
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-
-      expect(processSpy).toHaveBeenCalledWith(initialSession)
-
-      expect(sessionStoreStrategy.retrieveSession()).toEqual(EXPIRED_SESSION)
-      expect(afterSpy).toHaveBeenCalledWith(EXPIRED_SESSION)
-    })
-
-    it('should not persist session when process returns undefined', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: true, initialSession })
-      processSpy.and.returnValue(undefined)
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-
-      expect(processSpy).toHaveBeenCalledWith(initialSession)
-      expect(sessionStoreStrategy.retrieveSession()).toEqual(initialSession)
-      expect(afterSpy).toHaveBeenCalledWith(initialSession)
-    })
-    ;[
-      {
-        description: 'should wait for lock to be free',
-        lockConflictOnRetrievedSessionIndex: 0,
-      },
-      {
-        description: 'should retry if lock was acquired before process',
-        lockConflictOnRetrievedSessionIndex: 1,
-      },
-      {
-        description: 'should retry if lock was acquired after process',
-        lockConflictOnRetrievedSessionIndex: 2,
-      },
-      {
-        description: 'should retry if lock was acquired after persist',
-        lockConflictOnRetrievedSessionIndex: 3,
-      },
-    ].forEach(({ description, lockConflictOnRetrievedSessionIndex }) => {
-      it(description, (done) => {
-        expandSessionState(initialSession)
-        const sessionStoreStrategy = createFakeSessionStoreStrategy({ isLockEnabled: true, initialSession })
-        sessionStoreStrategy.planRetrieveSession(lockConflictOnRetrievedSessionIndex, {
-          ...initialSession,
-          lock: createLock(),
-        })
-        sessionStoreStrategy.planRetrieveSession(lockConflictOnRetrievedSessionIndex + 1, {
-          ...initialSession,
-          other: 'other',
-        })
-        processSpy.and.callFake((session) => ({ ...session, processed: 'processed' }) as SessionState)
-
-        processSessionStoreOperations(
-          {
-            process: processSpy,
-            after: (afterSession) => {
-              // session with 'other' value on process
-              expect(processSpy).toHaveBeenCalledWith({
-                ...initialSession,
-                other: 'other',
-                expire: jasmine.any(String),
-              })
-
-              // end state with session 'other' and 'processed' value
-              const expectedSession = {
-                ...initialSession,
-                other: 'other',
-                processed: 'processed',
-                expire: jasmine.any(String),
-              }
-              expect(sessionStoreStrategy.retrieveSession()).toEqual(expectedSession)
-              expect(afterSession).toEqual(expectedSession)
-              done()
-            },
-          },
-          sessionStoreStrategy
-        )
-      })
-    })
-
-    it('should abort after a max number of retry', () => {
-      const clock = mockClock()
-
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({
-        isLockEnabled: true,
-        initialSession: { ...initialSession, lock: createLock() },
-      })
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-
-      clock.tick(LOCK_MAX_TRIES * LOCK_RETRY_DELAY)
-      expect(processSpy).not.toHaveBeenCalled()
-      expect(afterSpy).not.toHaveBeenCalled()
-      expect(sessionStoreStrategy.persistSession).not.toHaveBeenCalled()
-    })
-
-    it('should execute cookie accesses in order', (done) => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({
-        isLockEnabled: true,
-        initialSession: { ...initialSession, lock: createLock() },
-      })
-      sessionStoreStrategy.planRetrieveSession(1, initialSession)
-
-      processSessionStoreOperations(
-        {
-          process: (session) => ({ ...session, value: 'foo' }),
-          after: afterSpy,
-        },
-        sessionStoreStrategy
-      )
-      processSessionStoreOperations(
-        {
-          process: (session) => ({ ...session, value: `${session.value || ''}bar` }),
-          after: (session) => {
-            expect(session.value).toBe('foobar')
-            expect(afterSpy).toHaveBeenCalled()
-            done()
-          },
-        },
-        sessionStoreStrategy
-      )
-    })
-
-    it('ignores locks set by an older version of the SDK (without creation date)', () => {
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({
-        isLockEnabled: true,
-        initialSession: { ...initialSession, lock: 'locked' },
-      })
-
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-      expect(processSpy).toHaveBeenCalled()
-    })
-
-    it('ignores expired locks', () => {
-      const clock = mockClock()
-      const sessionStoreStrategy = createFakeSessionStoreStrategy({
-        isLockEnabled: true,
-        initialSession: { ...initialSession, lock: createLock() },
-      })
-      clock.tick(LOCK_EXPIRATION_DELAY + 1)
-      processSessionStoreOperations({ process: processSpy, after: afterSpy }, sessionStoreStrategy)
-      expect(processSpy).toHaveBeenCalled()
-    })
-  })
-})

package/src/domain/session/storeStrategies/sessionInCookie.spec.ts

@@ -1,228 +0,0 @@
-import { mockClock, getSessionState, registerCleanupTask } from '../../../../test'
-import { setCookie, deleteCookie, getCookie, getCurrentSite } from '../../../browser/cookie'
-import type { SessionState } from '../sessionState'
-import { validateAndBuildConfiguration } from '../../configuration'
-import type { InitConfiguration } from '../../configuration'
-import { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from '../sessionConstants'
-import { buildCookieOptions, selectCookieStrategy, initCookieStrategy } from './sessionInCookie'
-import { SESSION_STORE_KEY } from './sessionStoreStrategy'
-
-const DEFAULT_INIT_CONFIGURATION = { clientToken: 'abc', trackAnonymousUser: true }
-
-function setupCookieStrategy(partialInitConfiguration: Partial<InitConfiguration> = {}) {
-  const initConfiguration = {
-    ...DEFAULT_INIT_CONFIGURATION,
-    ...partialInitConfiguration,
-  } as InitConfiguration
-
-  const configuration = validateAndBuildConfiguration(initConfiguration)!
-  const cookieOptions = buildCookieOptions(initConfiguration)!
-
-  registerCleanupTask(() => deleteCookie(SESSION_STORE_KEY, cookieOptions))
-
-  return initCookieStrategy(configuration, cookieOptions)
-}
-
-describe('session in cookie strategy', () => {
-  const sessionState: SessionState = { id: '123', created: '0' }
-
-  it('should persist a session in a cookie', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    cookieStorageStrategy.persistSession(sessionState)
-    const session = cookieStorageStrategy.retrieveSession()
-    expect(session).toEqual({ ...sessionState })
-    expect(getCookie(SESSION_STORE_KEY)).toBe('id=123&created=0')
-  })
-
-  it('should set `isExpired=1` to the cookie holding the session', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    spyOn(Math, 'random').and.callFake(() => 0)
-    cookieStorageStrategy.persistSession(sessionState)
-    cookieStorageStrategy.expireSession(sessionState)
-    const session = cookieStorageStrategy.retrieveSession()
-    expect(session).toEqual({ isExpired: '1' })
-    expect(getSessionState(SESSION_STORE_KEY)).toEqual({ isExpired: '1' })
-  })
-
-  it('should not generate an anonymousId if not present', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    cookieStorageStrategy.persistSession(sessionState)
-    const session = cookieStorageStrategy.retrieveSession()
-    expect(session).toEqual({ id: '123', created: '0' })
-    expect(getSessionState(SESSION_STORE_KEY)).toEqual({ id: '123', created: '0' })
-  })
-
-  it('should return an empty object if session string is invalid', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    setCookie(SESSION_STORE_KEY, '{test:42}', 1000)
-    const session = cookieStorageStrategy.retrieveSession()
-    expect(session).toEqual({})
-  })
-
-  describe('build cookie options', () => {
-    const clientToken = 'abc'
-
-    it('should not be secure nor crossSite by default', () => {
-      const cookieOptions = buildCookieOptions({ clientToken })
-      expect(cookieOptions).toEqual({ secure: false, crossSite: false, partitioned: false })
-    })
-
-    it('should be secure when `useSecureSessionCookie` is truthy', () => {
-      const cookieOptions = buildCookieOptions({ clientToken, useSecureSessionCookie: true })
-      expect(cookieOptions).toEqual({ secure: true, crossSite: false, partitioned: false })
-    })
-
-    it('should be secure, crossSite and partitioned when `usePartitionedCrossSiteSessionCookie` is truthy', () => {
-      const cookieOptions = buildCookieOptions({ clientToken, usePartitionedCrossSiteSessionCookie: true })
-      expect(cookieOptions).toEqual({ secure: true, crossSite: true, partitioned: true })
-    })
-
-    it('should have domain when `trackSessionAcrossSubdomains` is truthy', () => {
-      const cookieOptions = buildCookieOptions({ clientToken, trackSessionAcrossSubdomains: true })
-      expect(cookieOptions).toEqual({
-        secure: false,
-        crossSite: false,
-        partitioned: false,
-        domain: jasmine.any(String),
-      })
-    })
-  })
-
-  describe('cookie options', () => {
-    ;[
-      {
-        initConfiguration: { clientToken: 'abc' },
-        cookieOptions: {},
-        cookieString: /^oo_cookie_test_[\w-]+=[^;]*;expires=[^;]+;path=\/;samesite=strict$/,
-        description: 'should set samesite to strict by default',
-      },
-      {
-        initConfiguration: { clientToken: 'abc', useSecureSessionCookie: true },
-        cookieOptions: { secure: true },
-        cookieString: /^oo_cookie_test_[\w-]+=[^;]*;expires=[^;]+;path=\/;samesite=strict;secure$/,
-        description: 'should add secure attribute when defined',
-      },
-      {
-        initConfiguration: { clientToken: 'abc', trackSessionAcrossSubdomains: true },
-        cookieOptions: { domain: 'foo.bar' },
-        cookieString: new RegExp(
-          `^oo_cookie_test_[\\w-]+=[^;]*;expires=[^;]+;path=\\/;samesite=strict;domain=${getCurrentSite()}$`
-        ),
-        description: 'should set cookie domain when tracking accross subdomains',
-      },
-    ].forEach(({ description, initConfiguration, cookieString }) => {
-      it(description, () => {
-        const cookieSetSpy = spyOnProperty(document, 'cookie', 'set')
-        selectCookieStrategy(initConfiguration)
-        expect(cookieSetSpy.calls.argsFor(0)[0]).toMatch(cookieString)
-      })
-    })
-  })
-
-  describe('encode cookie options', () => {
-    const config: Partial<InitConfiguration> = { betaEncodeCookieOptions: true }
-
-    it('should encode cookie options in the cookie value', () => {
-      // Some older browsers don't support partitioned cross-site session cookies
-      // so instead of testing the cookie value, we test the call to the cookie setter
-      const cookieSetSpy = spyOnProperty(document, 'cookie', 'set')
-      const cookieStorageStrategy = setupCookieStrategy({ usePartitionedCrossSiteSessionCookie: true, ...config })
-      cookieStorageStrategy.persistSession({ id: '123' })
-
-      const calls = cookieSetSpy.calls.all()
-      const lastCall = calls[calls.length - 1]
-      expect(lastCall.args[0]).toMatch(/^_oo_s=id=123&c=1/)
-    })
-
-    it('should not encode cookie options in the cookie value if the session is empty (deleting the cookie)', () => {
-      const cookieStorageStrategy = setupCookieStrategy({ usePartitionedCrossSiteSessionCookie: true, ...config })
-      cookieStorageStrategy.persistSession({})
-
-      expect(getCookie(SESSION_STORE_KEY)).toBeUndefined()
-    })
-
-    it('should return the correct session state from the cookies', () => {
-      spyOnProperty(document, 'cookie', 'get').and.returnValue('_oo_s=id=123&c=0;_oo_s=id=456&c=1;_oo_s=id=789&c=2')
-      const cookieStorageStrategy = setupCookieStrategy({ usePartitionedCrossSiteSessionCookie: true, ...config })
-
-      expect(cookieStorageStrategy.retrieveSession()).toEqual({ id: '456' })
-    })
-
-    it('should return the session state from the first cookie if there is no match', () => {
-      spyOnProperty(document, 'cookie', 'get').and.returnValue('_oo_s=id=123&c=0;_oo_s=id=789&c=2')
-      const cookieStorageStrategy = setupCookieStrategy({ usePartitionedCrossSiteSessionCookie: true, ...config })
-
-      expect(cookieStorageStrategy.retrieveSession()).toEqual({ id: '123' })
-    })
-  })
-})
-
-describe('session in cookie strategy when opt-in anonymous user tracking', () => {
-  const anonymousId = 'device-123'
-  const sessionState: SessionState = { id: '123', created: '0' }
-
-  it('should persist with anonymous id', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    cookieStorageStrategy.persistSession({ ...sessionState, anonymousId })
-    const session = cookieStorageStrategy.retrieveSession()
-    expect(session).toEqual({ ...sessionState, anonymousId })
-    expect(getCookie(SESSION_STORE_KEY)).toBe('id=123&created=0&aid=device-123')
-  })
-
-  it('should expire with anonymous id', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    cookieStorageStrategy.expireSession({ ...sessionState, anonymousId })
-    const session = cookieStorageStrategy.retrieveSession()
-    expect(session).toEqual({ isExpired: '1', anonymousId })
-    expect(getCookie(SESSION_STORE_KEY)).toBe('isExpired=1&aid=device-123')
-  })
-
-  it('should persist for one year when opt-in', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    const cookieSetSpy = spyOnProperty(document, 'cookie', 'set')
-    const clock = mockClock()
-    cookieStorageStrategy.persistSession({ ...sessionState, anonymousId })
-    expect(cookieSetSpy.calls.argsFor(0)[0]).toContain(
-      new Date(clock.timeStamp(SESSION_COOKIE_EXPIRATION_DELAY)).toUTCString()
-    )
-  })
-
-  it('should expire in one year when opt-in', () => {
-    const cookieStorageStrategy = setupCookieStrategy()
-    const cookieSetSpy = spyOnProperty(document, 'cookie', 'set')
-    const clock = mockClock()
-    cookieStorageStrategy.expireSession({ ...sessionState, anonymousId })
-    expect(cookieSetSpy.calls.argsFor(0)[0]).toContain(
-      new Date(clock.timeStamp(SESSION_COOKIE_EXPIRATION_DELAY)).toUTCString()
-    )
-  })
-})
-
-describe('session in cookie strategy when opt-out anonymous user tracking', () => {
-  const anonymousId = 'device-123'
-  const sessionState: SessionState = { id: '123', created: '0' }
-
-  it('should not extend cookie expiration time when opt-out', () => {
-    const cookieStorageStrategy = setupCookieStrategy({ trackAnonymousUser: false })
-    const cookieSetSpy = spyOnProperty(document, 'cookie', 'set')
-    const clock = mockClock()
-    cookieStorageStrategy.expireSession({ ...sessionState, anonymousId })
-    expect(cookieSetSpy.calls.argsFor(0)[0]).toContain(new Date(clock.timeStamp(SESSION_TIME_OUT_DELAY)).toUTCString())
-  })
-
-  it('should not persist with one year when opt-out', () => {
-    const cookieStorageStrategy = setupCookieStrategy({ trackAnonymousUser: false })
-    const cookieSetSpy = spyOnProperty(document, 'cookie', 'set')
-    cookieStorageStrategy.persistSession({ ...sessionState, anonymousId })
-    expect(cookieSetSpy.calls.argsFor(0)[0]).toContain(new Date(Date.now() + SESSION_EXPIRATION_DELAY).toUTCString())
-  })
-
-  it('should not persist or expire a session with anonymous id when opt-out', () => {
-    const cookieStorageStrategy = setupCookieStrategy({ trackAnonymousUser: false })
-    cookieStorageStrategy.persistSession({ ...sessionState, anonymousId })
-    cookieStorageStrategy.expireSession({ ...sessionState, anonymousId })
-    const session = cookieStorageStrategy.retrieveSession()
-    expect(session).toEqual({ isExpired: '1' })
-    expect(getCookie(SESSION_STORE_KEY)).toBe('isExpired=1')
-  })
-})

package/src/domain/session/storeStrategies/sessionInLocalStorage.spec.ts

@@ -1,75 +0,0 @@
-import type { Configuration } from '../../configuration'
-import { SessionPersistence } from '../sessionConstants'
-import { toSessionState } from '../sessionState'
-import type { SessionState } from '../sessionState'
-import { selectLocalStorageStrategy, initLocalStorageStrategy } from './sessionInLocalStorage'
-import { SESSION_STORE_KEY } from './sessionStoreStrategy'
-const DEFAULT_INIT_CONFIGURATION = { trackAnonymousUser: true } as Configuration
-
-function getSessionStateFromLocalStorage(SESSION_STORE_KEY: string): SessionState {
-  return toSessionState(window.localStorage.getItem(SESSION_STORE_KEY))
-}
-describe('session in local storage strategy', () => {
-  const sessionState: SessionState = { id: '123', created: '0' }
-  beforeEach(() => {
-    spyOn(Math, 'random').and.returnValue(0)
-  })
-
-  afterEach(() => {
-    window.localStorage.clear()
-  })
-
-  it('should report local storage as available', () => {
-    const available = selectLocalStorageStrategy()
-    expect(available).toEqual({ type: SessionPersistence.LOCAL_STORAGE })
-  })
-
-  it('should report local storage as not available', () => {
-    spyOn(Storage.prototype, 'getItem').and.throwError('Unavailable')
-    const available = selectLocalStorageStrategy()
-    expect(available).toBeUndefined()
-  })
-
-  it('should persist a session in local storage', () => {
-    const localStorageStrategy = initLocalStorageStrategy(DEFAULT_INIT_CONFIGURATION)
-    localStorageStrategy.persistSession(sessionState)
-    const session = localStorageStrategy.retrieveSession()
-    expect(session).toEqual({ ...sessionState })
-    expect(getSessionStateFromLocalStorage(SESSION_STORE_KEY)).toEqual(sessionState)
-  })
-
-  it('should set `isExpired=1` to the local storage item holding the session', () => {
-    const localStorageStrategy = initLocalStorageStrategy(DEFAULT_INIT_CONFIGURATION)
-    localStorageStrategy.persistSession(sessionState)
-    localStorageStrategy.expireSession(sessionState)
-    const session = localStorageStrategy?.retrieveSession()
-    expect(session).toEqual({ isExpired: '1' })
-    expect(getSessionStateFromLocalStorage(SESSION_STORE_KEY)).toEqual({
-      isExpired: '1',
-    })
-  })
-
-  it('should not generate an anonymousId if not present', () => {
-    const localStorageStrategy = initLocalStorageStrategy(DEFAULT_INIT_CONFIGURATION)
-    localStorageStrategy.persistSession(sessionState)
-    const session = localStorageStrategy.retrieveSession()
-    expect(session).toEqual({ id: '123', created: '0' })
-    expect(getSessionStateFromLocalStorage(SESSION_STORE_KEY)).toEqual({ id: '123', created: '0' })
-  })
-
-  it('should return an empty object if session string is invalid', () => {
-    const localStorageStrategy = initLocalStorageStrategy(DEFAULT_INIT_CONFIGURATION)
-    window.localStorage.setItem(SESSION_STORE_KEY, '{test:42}')
-    const session = localStorageStrategy.retrieveSession()
-    expect(session).toEqual({})
-  })
-
-  it('should not interfere with other keys present in local storage', () => {
-    window.localStorage.setItem('test', 'hello')
-    const localStorageStrategy = initLocalStorageStrategy(DEFAULT_INIT_CONFIGURATION)
-    localStorageStrategy.persistSession(sessionState)
-    localStorageStrategy.retrieveSession()
-    localStorageStrategy.expireSession(sessionState)
-    expect(window.localStorage.getItem('test')).toEqual('hello')
-  })
-})

package/src/domain/synthetics/syntheticsWorkerValues.spec.ts

@@ -1,82 +0,0 @@
-import { mockSyntheticsWorkerValues } from '../../../test'
-import { getSyntheticsResultId, getSyntheticsTestId, willSyntheticsInjectRum } from './syntheticsWorkerValues'
-
-describe('syntheticsWorkerValues', () => {
-  describe('willSyntheticsInjectRum', () => {
-    it('returns false if nothing is defined', () => {
-      mockSyntheticsWorkerValues({}, 'globals')
-
-      expect(willSyntheticsInjectRum()).toBeFalse()
-    })
-
-    it('returns false if the INJECTS_RUM global variable is false', () => {
-      mockSyntheticsWorkerValues({ injectsRum: false }, 'globals')
-
-      expect(willSyntheticsInjectRum()).toBeFalse()
-    })
-
-    it('returns true if the INJECTS_RUM global variable is truthy', () => {
-      mockSyntheticsWorkerValues({ injectsRum: true }, 'globals')
-
-      expect(willSyntheticsInjectRum()).toBeTrue()
-    })
-
-    it('returns true if the INJECTS_RUM cookie is truthy', () => {
-      mockSyntheticsWorkerValues({ injectsRum: true }, 'cookies')
-
-      expect(willSyntheticsInjectRum()).toBeTrue()
-    })
-  })
-
-  describe('getSyntheticsTestId', () => {
-    it('returns undefined if nothing is defined', () => {
-      mockSyntheticsWorkerValues({}, 'globals')
-
-      expect(getSyntheticsTestId()).toBeUndefined()
-    })
-
-    it('returns the test id if the PUBLIC_ID global variable is defined', () => {
-      mockSyntheticsWorkerValues({ publicId: 'toto' }, 'globals')
-
-      expect(getSyntheticsTestId()).toBe('toto')
-    })
-
-    it('returns undefined if the PUBLIC_ID global variable is not a string', () => {
-      mockSyntheticsWorkerValues({ publicId: 1 }, 'globals')
-
-      expect(getSyntheticsTestId()).toBeUndefined()
-    })
-
-    it('returns undefined if the PUBLIC_ID cookie is defined', () => {
-      mockSyntheticsWorkerValues({ publicId: 'toto' }, 'cookies')
-
-      expect(getSyntheticsTestId()).toBe('toto')
-    })
-  })
-
-  describe('getSyntheticsResultId', () => {
-    it('returns undefined if nothing is defined', () => {
-      mockSyntheticsWorkerValues({}, 'globals')
-
-      expect(getSyntheticsResultId()).toBeUndefined()
-    })
-
-    it('returns the test id if the RESULT_ID global variable is defined', () => {
-      mockSyntheticsWorkerValues({ resultId: 'toto' }, 'globals')
-
-      expect(getSyntheticsResultId()).toBe('toto')
-    })
-
-    it('returns undefined if the RESULT_ID global variable is not a string', () => {
-      mockSyntheticsWorkerValues({ resultId: 1 }, 'globals')
-
-      expect(getSyntheticsResultId()).toBeUndefined()
-    })
-
-    it('returns undefined if the RESULT_ID cookie is defined', () => {
-      mockSyntheticsWorkerValues({ resultId: 'toto' }, 'cookies')
-
-      expect(getSyntheticsResultId()).toBe('toto')
-    })
-  })
-})