@openobserve/browser-core 0.2.12-beta.7 → 0.3.0

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

@@ -0,0 +1,234 @@
+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

@@ -0,0 +1,228 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,82 @@
+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')
+    })
+  })
+})