@openobserve/browser-core 0.2.12-beta.9 → 0.3.1

package/src/domain/connectivity/connectivity.spec.ts

@@ -0,0 +1,50 @@
+import { setNavigatorOnLine, setNavigatorConnection } from '../../../test'
+import { getConnectivity } from './connectivity'
+
+describe('connectivity', () => {
+  describe('status', () => {
+    it('should return `connected` when navigator.onLine is true', () => {
+      setNavigatorOnLine(true)
+      expect(getConnectivity().status).toEqual('connected')
+    })
+
+    it('should return `not_connected` when navigator.onLine is false', () => {
+      setNavigatorOnLine(false)
+      expect(getConnectivity().status).toEqual('not_connected')
+    })
+  })
+
+  describe('interfaces', () => {
+    it('should not be defined if navigator.connection is not available', () => {
+      setNavigatorConnection(undefined)
+      expect(getConnectivity().interfaces).toBeUndefined()
+    })
+
+    it('should not be defined if navigator.connection.type is not available', () => {
+      setNavigatorConnection({})
+      expect(getConnectivity().interfaces).toBeUndefined()
+    })
+
+    it('should return navigator.connection.type value', () => {
+      setNavigatorConnection({ type: 'bluetooth' })
+      expect(getConnectivity().interfaces).toEqual(['bluetooth'])
+    })
+  })
+
+  describe('effective_type', () => {
+    it('should not be defined if navigator.connection is not available', () => {
+      setNavigatorConnection(undefined)
+      expect(getConnectivity().effective_type).toBeUndefined()
+    })
+
+    it('should not be defined if navigator.connection.effective_type is not available', () => {
+      setNavigatorConnection({})
+      expect(getConnectivity().effective_type).toBeUndefined()
+    })
+
+    it('should return navigator.connection.effective_type value', () => {
+      setNavigatorConnection({ effectiveType: '4g' })
+      expect(getConnectivity().effective_type).toBe('4g')
+    })
+  })
+})

package/src/domain/console/consoleObservable.spec.ts

@@ -0,0 +1,151 @@
+/* eslint-disable no-console */
+import { ignoreConsoleLogs } from '../../../test'
+import { ConsoleApiName } from '../../tools/display'
+import type { Subscription } from '../../tools/observable'
+import type { ErrorConsoleLog } from './consoleObservable'
+import { initConsoleObservable } from './consoleObservable'
+
+// prettier: avoid formatting issue
+// cf https://github.com/prettier/prettier/issues/12211
+;[
+  { api: ConsoleApiName.log },
+  { api: ConsoleApiName.info },
+  { api: ConsoleApiName.warn },
+  { api: ConsoleApiName.debug },
+  { api: ConsoleApiName.error },
+].forEach(({ api }) => {
+  describe(`console ${api} observable`, () => {
+    let consoleSpy: jasmine.Spy
+    let consoleSubscription: Subscription
+    let notifyLog: jasmine.Spy
+
+    beforeEach(() => {
+      consoleSpy = spyOn(console, api)
+      notifyLog = jasmine.createSpy('notifyLog')
+
+        consoleSubscription = initConsoleObservable([api]).subscribe(notifyLog)
+      })
+
+      afterEach(() => {
+        consoleSubscription.unsubscribe()
+      })
+
+      it(`should notify ${api}`, () => {
+        console[api]('foo', 'bar')
+
+        const consoleLog = notifyLog.calls.mostRecent().args[0]
+
+      expect(consoleLog).toEqual(
+        jasmine.objectContaining({
+          message: 'foo bar',
+          api,
+        })
+      )
+    })
+
+      it('should keep original behavior', () => {
+        console[api]('foo', 'bar')
+
+      expect(consoleSpy).toHaveBeenCalledWith('foo', 'bar')
+    })
+
+    it('should format error instance', () => {
+      console[api](new TypeError('hello'))
+      const consoleLog = notifyLog.calls.mostRecent().args[0]
+      expect(consoleLog.message).toBe('TypeError: hello')
+    })
+
+    it('should stringify object parameters', () => {
+      console[api]('Hello', { foo: 'bar' })
+      const consoleLog = notifyLog.calls.mostRecent().args[0]
+      expect(consoleLog.message).toBe('Hello {\n  "foo": "bar"\n}')
+    })
+
+      it('should allow multiple callers', () => {
+        const notifyOtherCaller = jasmine.createSpy('notifyOtherCaller')
+        const instrumentedConsoleApi = console[api]
+        const otherConsoleSubscription = initConsoleObservable([api]).subscribe(notifyOtherCaller)
+
+        console[api]('foo', 'bar')
+
+        expect(instrumentedConsoleApi).toEqual(console[api])
+        expect(notifyLog).toHaveBeenCalledTimes(1)
+        expect(notifyOtherCaller).toHaveBeenCalledTimes(1)
+
+        otherConsoleSubscription.unsubscribe()
+      })
+    })
+  })
+
+describe('console error observable', () => {
+  let consoleSubscription: Subscription
+  let notifyLog: jasmine.Spy<(consoleLog: ErrorConsoleLog) => void>
+
+  beforeEach(() => {
+    ignoreConsoleLogs('error', 'Error: foo')
+    ignoreConsoleLogs('error', 'foo bar')
+    notifyLog = jasmine.createSpy('notifyLog')
+
+    consoleSubscription = initConsoleObservable([ConsoleApiName.error]).subscribe(notifyLog)
+  })
+
+  afterEach(() => {
+    consoleSubscription.unsubscribe()
+  })
+
+  it('should generate a handling stack', () => {
+    function triggerError() {
+      console.error('foo', 'bar')
+    }
+    triggerError()
+    const consoleLog = notifyLog.calls.mostRecent().args[0]
+    expect(consoleLog.handlingStack).toMatch(/^HandlingStack: console error\s+at triggerError (.|\n)*$/)
+  })
+
+  it('should extract stack from first error', () => {
+    console.error(new TypeError('foo'), new TypeError('bar'))
+    const stack = notifyLog.calls.mostRecent().args[0].error.stack
+    expect(stack).toContain('TypeError: foo')
+  })
+
+  it('should retrieve fingerprint from error', () => {
+    interface DatadogError extends Error {
+      oo_fingerprint?: string
+    }
+    const error = new Error('foo')
+      ; (error as DatadogError).oo_fingerprint = 'my-fingerprint'
+
+    console.error(error)
+
+    const consoleLog = notifyLog.calls.mostRecent().args[0]
+    expect(consoleLog.error.fingerprint).toBe('my-fingerprint')
+  })
+
+  it('should sanitize error fingerprint', () => {
+    const error = new Error('foo')
+      ; (error as any).oo_fingerprint = 2
+
+    console.error(error)
+
+    const consoleLog = notifyLog.calls.mostRecent().args[0]
+    expect(consoleLog.error.fingerprint).toBe('2')
+  })
+
+  it('should retrieve context from error', () => {
+    interface DatadogError extends Error {
+      dd_context?: Record<string, unknown>
+    }
+    const error = new Error('foo')
+    ;(error as DatadogError).dd_context = { foo: 'bar' }
+    console.error(error)
+    const consoleLog = notifyLog.calls.mostRecent().args[0]
+    expect(consoleLog.error.context).toEqual({ foo: 'bar' })
+  })
+
+  it('should report original error', () => {
+    const error = new Error('foo')
+    console.error(error)
+    const consoleLog = notifyLog.calls.mostRecent().args[0]
+    expect(consoleLog.error.originalError).toBe(error)
+  })
+})

package/src/domain/context/contextManager.spec.ts

@@ -0,0 +1,152 @@
+import { display } from '../../tools/display'
+import type { PropertiesConfig } from './contextManager'
+import { createContextManager } from './contextManager'
+
+function createContextManagerWithDefaults(propertiesConfig?: PropertiesConfig) {
+  return createContextManager('test', { propertiesConfig })
+}
+
+describe('createContextManager', () => {
+  it('starts with an empty context', () => {
+    const manager = createContextManagerWithDefaults()
+    expect(manager.getContext()).toEqual({})
+  })
+
+  it('updates the context', () => {
+    const manager = createContextManagerWithDefaults()
+    manager.setContext({ bar: 'foo' })
+
+    expect(manager.getContext()).toEqual({ bar: 'foo' })
+  })
+
+  it('completely replaces the context', () => {
+    const manager = createContextManagerWithDefaults()
+    manager.setContext({ a: 'foo' })
+    expect(manager.getContext()).toEqual({ a: 'foo' })
+    manager.setContext({ b: 'foo' })
+    expect(manager.getContext()).toEqual({ b: 'foo' })
+  })
+
+  it('sets a context value', () => {
+    const manager = createContextManagerWithDefaults()
+    manager.setContextProperty('foo', 'bar')
+    expect(manager.getContext()).toEqual({ foo: 'bar' })
+  })
+
+  it('removes a context value', () => {
+    const manager = createContextManagerWithDefaults()
+    manager.setContext({ a: 'foo', b: 'bar' })
+    manager.removeContextProperty('a')
+    expect(manager.getContext()).toEqual({ b: 'bar' })
+    manager.removeContextProperty('b')
+    expect(manager.getContext()).toEqual({})
+  })
+
+  it('should get a clone of the context from getContext', () => {
+    const manager = createContextManagerWithDefaults()
+    expect(manager.getContext()).toEqual(manager.getContext())
+    expect(manager.getContext()).not.toBe(manager.getContext())
+  })
+
+  it('should set a clone of context via setContext', () => {
+    const nestedObject = { foo: 'bar' }
+    const context = { nested: nestedObject }
+    const manager = createContextManagerWithDefaults()
+    manager.setContext(context)
+    expect(manager.getContext().nested).toEqual(nestedObject)
+    expect(manager.getContext().nested).not.toBe(nestedObject)
+  })
+
+  it('should set a clone of the property via setContextProperty', () => {
+    const nestedObject = { foo: 'bar' }
+    const manager = createContextManagerWithDefaults()
+    manager.setContextProperty('nested', nestedObject)
+    expect(manager.getContext().nested).toEqual(nestedObject)
+    expect(manager.getContext().nested).not.toBe(nestedObject)
+  })
+
+  it('should clear context object via clearContext', () => {
+    const context = { foo: 'bar' }
+    const manager = createContextManagerWithDefaults()
+    manager.setContext(context)
+    expect(manager.getContext()).toEqual(context)
+    manager.clearContext()
+    expect(manager.getContext()).toEqual({})
+  })
+
+  it('should prevent setting non object values', () => {
+    spyOn(display, 'error')
+    const manager = createContextManagerWithDefaults()
+    manager.setContext(null as any)
+    expect(manager.getContext()).toEqual({})
+    manager.setContext(undefined as any)
+    expect(manager.getContext()).toEqual({})
+    manager.setContext(2 as any)
+    expect(manager.getContext()).toEqual({})
+  })
+
+  describe('type enforcement', () => {
+    const NULLISH_VALUES = [undefined, null, '']
+
+    it('should enforce specified type on properties', () => {
+      const manager = createContextManagerWithDefaults({
+        id: { type: 'string' },
+        name: { type: 'string' },
+        email: { type: 'string' },
+      })
+
+      manager.setContext({ id: 42, name: true, email: {} })
+
+      expect(manager.getContext()).toEqual({ id: '42', name: 'true', email: '[object Object]' })
+    })
+
+    it('should not enforce specified type on null or undefined properties', () => {
+      const manager = createContextManagerWithDefaults({
+        id: { type: 'string' },
+        name: { type: 'string' },
+      })
+
+      manager.setContext({ id: undefined, name: null })
+      expect(manager.getContext()).toEqual({ id: undefined, name: null })
+    })
+
+    NULLISH_VALUES.forEach((value) => {
+      it(`should warn when required property is  ${value}`, () => {
+        const displaySpy = spyOn(display, 'warn')
+
+        const manager = createContextManagerWithDefaults({
+          id: { required: true },
+        })
+
+        manager.setContext({ id: value })
+
+        expect(displaySpy).toHaveBeenCalledOnceWith(
+          'The property id of test is required; context will not be sent to the intake.'
+        )
+      })
+    })
+  })
+
+  describe('changeObservable', () => {
+    it('should notify on context changes', () => {
+      const changeSpy = jasmine.createSpy('change')
+      const manager = createContextManagerWithDefaults()
+      manager.changeObservable.subscribe(changeSpy)
+
+      manager.getContext()
+      expect(changeSpy).not.toHaveBeenCalled()
+
+      manager.setContext({ foo: 'bar' })
+      expect(changeSpy).toHaveBeenCalledTimes(1)
+
+      manager.setContextProperty('qux', 'qix')
+      expect(changeSpy).toHaveBeenCalledTimes(2)
+
+      manager.removeContextProperty('qux')
+      expect(changeSpy).toHaveBeenCalledTimes(3)
+
+      manager.clearContext()
+      expect(changeSpy).toHaveBeenCalledTimes(4)
+    })
+  })
+})

package/src/domain/context/contextUtils.spec.ts

@@ -0,0 +1,26 @@
+import { display } from '../../tools/display'
+import type { Context } from '../../tools/serialisation/context'
+import type { Account } from '../contexts/accountContext'
+import type { User } from '../contexts/userContext'
+import { checkContext } from './contextUtils'
+
+describe('checkContext function', () => {
+  it('should only accept valid objects', () => {
+    spyOn(display, 'error')
+
+    const obj: any = { id: 42, name: true, email: null } // Valid, even though not sanitized
+    const user: User = { id: '42', name: 'John', email: 'john@doe.com' }
+    const account: Account = { id: '42', name: 'Groupe' }
+    const undefUser: any = undefined
+    const nullUser: any = null
+    const invalidUser: any = 42
+
+    expect(checkContext(obj)).toBe(true)
+    expect(checkContext(user as Context)).toBe(true)
+    expect(checkContext(account as Context)).toBe(true)
+    expect(checkContext(undefUser)).toBe(false)
+    expect(checkContext(nullUser)).toBe(false)
+    expect(checkContext(invalidUser)).toBe(false)
+    expect(display.error).toHaveBeenCalledTimes(3)
+  })
+})

package/src/domain/context/storeContextManager.spec.ts

@@ -0,0 +1,103 @@
+import type { Configuration } from '../configuration'
+import { createNewEvent } from '../../../test'
+import { DOM_EVENT } from '../../browser/addEventListener'
+import type { Context } from '../../tools/serialisation/context'
+import { storeContextManager, buildStorageKey, removeStorageListeners } from './storeContextManager'
+import { CustomerDataType } from './contextConstants'
+import { createContextManager } from './contextManager'
+
+describe('storeContextManager', () => {
+  const PRODUCT_KEY = 'fake'
+  const CUSTOMER_DATA_TYPE = CustomerDataType.User
+  const STORAGE_KEY = buildStorageKey(PRODUCT_KEY, CUSTOMER_DATA_TYPE)
+
+  let configuration: Configuration
+
+  beforeEach(() => {
+    configuration = {} as Configuration
+  })
+
+  afterEach(() => {
+    localStorage.clear()
+    removeStorageListeners()
+  })
+
+  it('should synchronize with local storage at start', () => {
+    localStorage.setItem(STORAGE_KEY, '{"bar":"foo"}')
+
+    const manager = createStoredContextManager()
+
+    expect(manager.getContext()).toEqual({ bar: 'foo' })
+  })
+
+  it('should synchronize with local storage on storage events', () => {
+    const manager = createStoredContextManager()
+
+    localStorage.setItem(STORAGE_KEY, '{"bar":"foo"}')
+    expect(manager.getContext()).toEqual({})
+
+    window.dispatchEvent(createNewEvent(DOM_EVENT.STORAGE, { key: 'unknown' }))
+    expect(manager.getContext()).toEqual({})
+
+    window.dispatchEvent(createNewEvent(DOM_EVENT.STORAGE, { key: STORAGE_KEY }))
+    expect(manager.getContext()).toEqual({ bar: 'foo' })
+  })
+
+  it('should update local storage on context updates', () => {
+    const manager = createStoredContextManager()
+    expect(localStorage.getItem(STORAGE_KEY)).toBe(null)
+
+    manager.setContext({ bar: 'foo' })
+    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo"}')
+
+    manager.setContextProperty('qux', 'qix')
+    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo","qux":"qix"}')
+
+    manager.removeContextProperty('qux')
+    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo"}')
+
+    manager.clearContext()
+    expect(localStorage.getItem(STORAGE_KEY)).toBe('{}')
+  })
+
+  it('merges local storage data with initial context', () => {
+    localStorage.setItem(STORAGE_KEY, '{"bar":"foo"}')
+    const manager = createStoredContextManager({ initialContext: { qux: 'qix' } })
+
+    expect(manager.getContext()).toEqual({ bar: 'foo', qux: 'qix' })
+    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo","qux":"qix"}')
+  })
+
+  it('should store different product data in different storage key', () => {
+    createStoredContextManager({ initialContext: { bar: 'foo' }, productKey: 'p1' })
+    createStoredContextManager({ initialContext: { qux: 'qix' }, productKey: 'p2' })
+
+    expect(localStorage.getItem(buildStorageKey('p1', CUSTOMER_DATA_TYPE))).toBe('{"bar":"foo"}')
+    expect(localStorage.getItem(buildStorageKey('p2', CUSTOMER_DATA_TYPE))).toBe('{"qux":"qix"}')
+  })
+
+  it('should store different data type in different storage key', () => {
+    createStoredContextManager({ initialContext: { bar: 'foo' }, customerDataType: CustomerDataType.User })
+    createStoredContextManager({ initialContext: { qux: 'qix' }, customerDataType: CustomerDataType.GlobalContext })
+
+    expect(localStorage.getItem(buildStorageKey(PRODUCT_KEY, CustomerDataType.User))).toBe('{"bar":"foo"}')
+    expect(localStorage.getItem(buildStorageKey(PRODUCT_KEY, CustomerDataType.GlobalContext))).toBe('{"qux":"qix"}')
+  })
+
+  function createStoredContextManager({
+    initialContext,
+    productKey = PRODUCT_KEY,
+    customerDataType = CUSTOMER_DATA_TYPE,
+  }: {
+    initialContext?: Context
+    productKey?: string
+    customerDataType?: CustomerDataType
+  } = {}) {
+    const manager = createContextManager('test')
+    if (initialContext) {
+      manager.setContext(initialContext)
+    }
+    storeContextManager(configuration, manager, productKey, customerDataType)
+    return manager
+  }
+})

package/src/domain/context/storeContextManager.ts

@@ -6,7 +6,7 @@ import { isEmptyObject } from '../../tools/utils/objectUtils'
 import type { ContextManager } from './contextManager'
 import type { CustomerDataType } from './contextConstants'
 
-const CONTEXT_STORE_KEY_PREFIX = '_dd_c'
+const CONTEXT_STORE_KEY_PREFIX = '_oo_c'
 
 const storageListeners: Array<{ stop: () => void }> = []
 

package/src/domain/contexts/accountContext.spec.ts

@@ -0,0 +1,99 @@
+import type { Hooks } from '../../../test'
+import { createHooks, registerCleanupTask } from '../../../test'
+import { mockRumConfiguration } from '../../../../rum-core/test'
+import type { ContextManager } from '../context/contextManager'
+import { display } from '../../tools/display'
+import type { RelativeTime } from '../../tools/utils/timeUtils'
+import { HookNames } from '../../tools/abstractHooks'
+import { removeStorageListeners } from '../context/storeContextManager'
+import { startAccountContext } from './accountContext'
+
+describe('account context', () => {
+  let accountContext: ContextManager
+  let displaySpy: jasmine.Spy
+  let hooks: Hooks
+
+  beforeEach(() => {
+    hooks = createHooks()
+    displaySpy = spyOn(display, 'warn')
+
+    accountContext = startAccountContext(hooks, mockRumConfiguration(), 'some_product_key')
+  })
+
+  it('should warn when the account.id is missing', () => {
+    accountContext.setContext({ foo: 'bar' })
+    expect(displaySpy).toHaveBeenCalled()
+  })
+
+  it('should sanitize predefined properties', () => {
+    accountContext.setContext({ id: false, name: 2 })
+    expect(accountContext.getContext()).toEqual({
+      id: 'false',
+      name: '2',
+    })
+  })
+
+  describe('assemble hook', () => {
+    it('should set the account', () => {
+      accountContext.setContext({ id: '123', foo: 'bar' })
+
+      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
+        startTime: 0 as RelativeTime,
+      })
+
+      expect(defaultRumEventAttributes).toEqual({
+        account: {
+          id: '123',
+          foo: 'bar',
+        },
+      })
+    })
+
+    it('should not set the account when account.id is undefined', () => {
+      accountContext.setContext({ foo: 'bar' })
+      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
+        eventType: 'view',
+        startTime: 0 as RelativeTime,
+      })
+
+      expect(defaultRumEventAttributes).toBeUndefined()
+    })
+  })
+})
+
+describe('account context across pages', () => {
+  let accountContext: ContextManager
+  let hooks: Hooks
+  beforeEach(() => {
+    hooks = createHooks()
+
+    registerCleanupTask(() => {
+      localStorage.clear()
+      removeStorageListeners()
+    })
+  })
+
+  it('when disabled, should store contexts only in memory', () => {
+    accountContext = startAccountContext(
+      hooks,
+      mockRumConfiguration({ storeContextsAcrossPages: false }),
+      'some_product_key'
+    )
+    accountContext.setContext({ id: '123' })
+
+    expect(accountContext.getContext()).toEqual({ id: '123' })
+    expect(localStorage.getItem('_oo_c_rum_4')).toBeNull()
+  })
+
+  it('when enabled, should maintain the account in local storage', () => {
+    accountContext = startAccountContext(
+      hooks,
+      mockRumConfiguration({ storeContextsAcrossPages: true }),
+      'some_product_key'
+    )
+
+    accountContext.setContext({ id: 'foo', qux: 'qix' })
+    expect(accountContext.getContext()).toEqual({ id: 'foo', qux: 'qix' })
+    expect(localStorage.getItem('_oo_c_some_product_key_4')).toBe('{"id":"foo","qux":"qix"}')
+  })
+})

package/src/domain/contexts/globalContext.spec.ts

@@ -0,0 +1,88 @@
+import type { Hooks } from '../../../test'
+import type { LogsConfiguration } from '../../../../logs/src/domain/configuration'
+import type { ContextManager } from '../context/contextManager'
+import { HookNames } from '../../tools/abstractHooks'
+import type { RelativeTime } from '../../tools/utils/timeUtils'
+import { createHooks, registerCleanupTask } from '../../../test'
+import { removeStorageListeners } from '../context/storeContextManager'
+import type { Configuration } from '../configuration'
+import { startGlobalContext } from './globalContext'
+
+describe('logs global context', () => {
+  let globalContext: ContextManager
+  let hooks: Hooks
+
+  beforeEach(() => {
+    hooks = createHooks()
+  })
+
+  describe('assemble hook', () => {
+    it('should set the context in context in `context` namespace when specified', () => {
+      const contextNamespace = true
+      globalContext = startGlobalContext(hooks, {} as LogsConfiguration, 'some_product_key', contextNamespace)
+
+      globalContext.setContext({ id: '123', foo: 'bar' })
+      const event = hooks.triggerHook(HookNames.Assemble, { startTime: 0 as RelativeTime })
+
+      expect(event).toEqual({
+        context: {
+          id: '123',
+          foo: 'bar',
+        },
+      })
+    })
+
+    it('should set the context in root namespace when specified', () => {
+      const contextNamespace = false
+      globalContext = startGlobalContext(hooks, {} as LogsConfiguration, 'some_product_key', contextNamespace)
+
+      globalContext.setContext({ id: '123', foo: 'bar' })
+      const event = hooks.triggerHook(HookNames.Assemble, { startTime: 0 as RelativeTime })
+
+      expect(event).toEqual({
+        id: '123',
+        foo: 'bar',
+      })
+    })
+  })
+})
+
+describe('global context across pages', () => {
+  let globalContext: ContextManager
+  let hooks: Hooks
+
+  beforeEach(() => {
+    hooks = createHooks()
+
+    registerCleanupTask(() => {
+      localStorage.clear()
+      removeStorageListeners()
+    })
+  })
+
+  it('when disabled, should store contexts only in memory', () => {
+    globalContext = startGlobalContext(
+      hooks,
+      { storeContextsAcrossPages: false } as Configuration,
+      'some_product_key',
+      false
+    )
+    globalContext.setContext({ id: '123' })
+
+    expect(globalContext.getContext()).toEqual({ id: '123' })
+    expect(localStorage.getItem('_oo_c_some_product_key_2')).toBeNull()
+  })
+
+  it('when enabled, should maintain the global context in local storage', () => {
+    globalContext = startGlobalContext(
+      hooks,
+      { storeContextsAcrossPages: true } as Configuration,
+      'some_product_key',
+      false
+    )
+
+    globalContext.setContext({ id: 'foo', qux: 'qix' })
+    expect(globalContext.getContext()).toEqual({ id: 'foo', qux: 'qix' })
+    expect(localStorage.getItem('_oo_c_some_product_key_2')).toBe('{"id":"foo","qux":"qix"}')
+  })
+})