@openobserve/browser-core 0.3.4 → 0.4.0-beta.2

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/sessionStoreOperations.ts

@@ -1,131 +0,0 @@
-import { setTimeout } from '../../tools/timer'
-import { generateUUID } from '../../tools/utils/stringUtils'
-import type { TimeStamp } from '../../tools/utils/timeUtils'
-import { elapsed, ONE_SECOND, timeStampNow } from '../../tools/utils/timeUtils'
-import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
-import type { SessionState } from './sessionState'
-import { expandSessionState, isSessionInExpiredState } from './sessionState'
-
-interface Operations {
-  process: (sessionState: SessionState) => SessionState | undefined
-  after?: (sessionState: SessionState) => void
-}
-
-export const LOCK_RETRY_DELAY = 10
-export const LOCK_MAX_TRIES = 100
-
-// Locks should be hold for a few milliseconds top, just the time it takes to read and write a
-// cookie. Using one second should be enough in most situations.
-export const LOCK_EXPIRATION_DELAY = ONE_SECOND
-const LOCK_SEPARATOR = '--'
-
-const bufferedOperations: Operations[] = []
-let ongoingOperations: Operations | undefined
-
-export function processSessionStoreOperations(
-  operations: Operations,
-  sessionStoreStrategy: SessionStoreStrategy,
-  numberOfRetries = 0
-) {
-  const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy
-  const persistWithLock = (session: SessionState) => persistSession({ ...session, lock: currentLock })
-  const retrieveStore = () => {
-    const { lock, ...session } = sessionStoreStrategy.retrieveSession()
-    return {
-      session,
-      lock: lock && !isLockExpired(lock) ? lock : undefined,
-    }
-  }
-
-  if (!ongoingOperations) {
-    ongoingOperations = operations
-  }
-  if (operations !== ongoingOperations) {
-    bufferedOperations.push(operations)
-    return
-  }
-  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
-    next(sessionStoreStrategy)
-    return
-  }
-  let currentLock: string
-  let currentStore = retrieveStore()
-  if (isLockEnabled) {
-    // if someone has lock, retry later
-    if (currentStore.lock) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-    // acquire lock
-    currentLock = createLock()
-    persistWithLock(currentStore.session)
-    // if lock is not acquired, retry later
-    currentStore = retrieveStore()
-    if (currentStore.lock !== currentLock) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-  }
-  let processedSession = operations.process(currentStore.session)
-  if (isLockEnabled) {
-    // if lock corrupted after process, retry later
-    currentStore = retrieveStore()
-    if (currentStore.lock !== currentLock!) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-  }
-  if (processedSession) {
-    if (isSessionInExpiredState(processedSession)) {
-      expireSession(processedSession)
-    } else {
-      expandSessionState(processedSession)
-      if (isLockEnabled) {
-        persistWithLock(processedSession)
-      } else {
-        persistSession(processedSession)
-      }
-    }
-  }
-  if (isLockEnabled) {
-    // correctly handle lock around expiration would require to handle this case properly at several levels
-    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
-    if (!(processedSession && isSessionInExpiredState(processedSession))) {
-      // if lock corrupted after persist, retry later
-      currentStore = retrieveStore()
-      if (currentStore.lock !== currentLock!) {
-        retryLater(operations, sessionStoreStrategy, numberOfRetries)
-        return
-      }
-      persistSession(currentStore.session)
-      processedSession = currentStore.session
-    }
-  }
-  // call after even if session is not persisted in order to perform operations on
-  // up-to-date session state value => the value could have been modified by another tab
-  operations.after?.(processedSession || currentStore.session)
-  next(sessionStoreStrategy)
-}
-
-function retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {
-  setTimeout(() => {
-    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)
-  }, LOCK_RETRY_DELAY)
-}
-
-function next(sessionStore: SessionStoreStrategy) {
-  ongoingOperations = undefined
-  const nextOperations = bufferedOperations.shift()
-  if (nextOperations) {
-    processSessionStoreOperations(nextOperations, sessionStore)
-  }
-}
-
-export function createLock(): string {
-  return generateUUID() + LOCK_SEPARATOR + timeStampNow()
-}
-
-function isLockExpired(lock: string) {
-  const [, timeStamp] = lock.split(LOCK_SEPARATOR)
-  return !timeStamp || elapsed(Number(timeStamp) as TimeStamp, timeStampNow()) > LOCK_EXPIRATION_DELAY
-}

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')
-  })
-})