@newrelic/browser-agent 1.242.0 → 1.243.0

package/src/features/utils/handler-cache.test.js

@@ -1,72 +0,0 @@
-import { HandlerCache } from './handler-cache'
-
-jest.useFakeTimers()
-
-test('should immediately invoke handler when decision has already been made and is true', () => {
-  const handlerCache = new HandlerCache()
-  handlerCache.decide(true)
-
-  const handler = jest.fn()
-  handlerCache.settle(handler)
-
-  expect(handler).toHaveBeenCalled()
-})
-
-test('should not invoke handler when decision has already been made and is false', () => {
-  const handlerCache = new HandlerCache()
-  handlerCache.decide(false)
-
-  const handler = jest.fn()
-  handlerCache.settle(handler)
-
-  expect(handler).not.toHaveBeenCalled()
-})
-
-test('should cache the handler until a decision is made', () => {
-  const handlerCache = new HandlerCache()
-
-  const handler = jest.fn()
-  handlerCache.settle(handler)
-  expect(handler).not.toHaveBeenCalled()
-
-  handlerCache.decide(true)
-  expect(handler).toHaveBeenCalled()
-})
-
-test('should not invoke handler when decision times out', () => {
-  const handlerCache = new HandlerCache()
-  jest.advanceTimersByTime(10000)
-
-  const handler = jest.fn()
-  handlerCache.settle(handler)
-
-  expect(handler).not.toHaveBeenCalled()
-})
-
-test('should clear the timeout when a decision is made', () => {
-  jest.spyOn(global, 'setTimeout')
-  jest.spyOn(global, 'clearTimeout')
-
-  const handlerCache = new HandlerCache()
-
-  const handler = jest.fn()
-  handlerCache.settle(handler)
-  handlerCache.decide(true)
-
-  const timeout = jest.mocked(global.setTimeout).mock.results[0].value
-  expect(global.clearTimeout).toHaveBeenCalledWith(timeout)
-})
-
-test('should not allow another decision after a permanent one', () => {
-  jest.spyOn(global, 'clearTimeout')
-
-  const handlerCache = new HandlerCache()
-
-  const handler = jest.fn()
-  handlerCache.settle(handler)
-  handlerCache.permanentlyDecide(false)
-  handlerCache.decide(true)
-
-  expect(global.clearTimeout).toHaveBeenCalledTimes(1)
-  expect(handler).not.toHaveBeenCalled()
-})

package/src/features/utils/instrument-base.test.js

@@ -1,216 +0,0 @@
-import { faker } from '@faker-js/faker'
-import { InstrumentBase } from './instrument-base'
-import { FeatureBase } from './feature-base'
-import { drain, registerDrain } from '../../common/drain/drain'
-import { onWindowLoad } from '../../common/window/load'
-import { lazyFeatureLoader } from './lazy-feature-loader'
-import { getConfigurationValue } from '../../common/config/config'
-import { setupAgentSession } from './agent-session'
-import { warn } from '../../common/util/console'
-import * as globalScopeModule from '../../common/constants/runtime'
-import { FEATURE_NAMES } from '../../loaders/features/features'
-
-jest.enableAutomock()
-jest.unmock('./instrument-base')
-jest.unmock('../../loaders/features/features')
-jest.mock('../../common/drain/drain', () => ({
-  __esModule: true,
-  drain: jest.fn(),
-  registerDrain: jest.fn()
-}))
-jest.mock('../../common/window/load', () => ({
-  __esModule: true,
-  onWindowLoad: jest.fn()
-}))
-jest.mock('../../common/constants/runtime', () => ({
-  __esModule: true,
-  isBrowserScope: undefined,
-  isWorkerScope: undefined
-}))
-jest.mock('../../common/config/config', () => ({
-  __esModule: true,
-  getConfigurationValue: jest.fn()
-}))
-jest.mock('../../common/config/config', () => ({
-  __esModule: true,
-  getConfigurationValue: jest.fn().mockReturnValue({}),
-  originals: {
-    MO: jest.fn()
-  }
-}))
-jest.mock('./feature-base', () => ({
-  __esModule: true,
-  FeatureBase: jest.fn(function (...args) {
-    this.agentIdentifier = args[0]
-    this.aggregator = args[1]
-    this.featureName = args[2]
-  })
-}))
-jest.mock('./agent-session', () => ({
-  __esModule: true,
-  setupAgentSession: jest.fn()
-}))
-
-let agentIdentifier
-let aggregator
-let featureName
-let mockAggregate
-
-beforeEach(() => {
-  jest.replaceProperty(globalScopeModule, 'isBrowserScope', true)
-  jest.replaceProperty(globalScopeModule, 'isWorkerScope', false)
-
-  agentIdentifier = faker.datatype.uuid()
-  aggregator = {}
-  featureName = faker.datatype.uuid()
-
-  mockAggregate = jest.fn()
-  jest.mocked(lazyFeatureLoader).mockResolvedValue({ Aggregate: mockAggregate })
-})
-
-test('should construct a new instrument', () => {
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
-
-  expect(FeatureBase).toHaveBeenCalledWith(agentIdentifier, aggregator, featureName)
-  expect(instrument.featAggregate).toBeUndefined()
-  expect(instrument.auto).toEqual(true)
-  expect(instrument.abortHandler).toBeUndefined()
-  expect(registerDrain).toHaveBeenCalledWith(agentIdentifier, featureName)
-})
-
-test('should not immediately drain', () => {
-  new InstrumentBase(agentIdentifier, aggregator, featureName, false)
-
-  expect(registerDrain).not.toHaveBeenCalled()
-})
-
-test('should import aggregator on window load', async () => {
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
-  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  instrument.importAggregator(aggregateArgs)
-
-  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
-  await windowLoadCallback()
-
-  expect(onWindowLoad).toHaveBeenCalledWith(expect.any(Function), true)
-  expect(lazyFeatureLoader).toHaveBeenCalledWith(featureName, 'aggregate')
-  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
-})
-
-test('should immediately import aggregator in worker scope', async () => {
-  jest.replaceProperty(globalScopeModule, 'isBrowserScope', false)
-  jest.replaceProperty(globalScopeModule, 'isWorkerScope', true)
-
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
-  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  instrument.importAggregator(aggregateArgs)
-
-  // In worker scope, we cannot wait on importLater method
-  await new Promise(process.nextTick)
-
-  expect(onWindowLoad).not.toHaveBeenCalled()
-  expect(lazyFeatureLoader).toHaveBeenCalledWith(featureName, 'aggregate')
-  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
-})
-
-test('should import the session manager and replay aggregate for new session', async () => {
-  jest.mocked(getConfigurationValue).mockReturnValue(true)
-  jest.mocked(setupAgentSession).mockReturnValue({
-    isNew: true
-  })
-
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, FEATURE_NAMES.sessionReplay)
-  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  instrument.importAggregator(aggregateArgs)
-
-  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
-  await windowLoadCallback()
-
-  expect(getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled')
-  expect(setupAgentSession).toHaveBeenCalledWith(agentIdentifier)
-  expect(lazyFeatureLoader).toHaveBeenCalledWith(FEATURE_NAMES.sessionReplay, 'aggregate')
-  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
-})
-
-test('should import the session manager and replay aggregate when a recording is active', async () => {
-  jest.mocked(getConfigurationValue).mockReturnValue(true)
-  jest.mocked(setupAgentSession).mockReturnValue({
-    isNew: false,
-    state: {
-      sessionReplay: 1
-    }
-  })
-
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, FEATURE_NAMES.sessionReplay)
-  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  instrument.importAggregator(aggregateArgs)
-
-  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
-  await windowLoadCallback()
-
-  expect(getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled')
-  expect(setupAgentSession).toHaveBeenCalledWith(agentIdentifier)
-  expect(lazyFeatureLoader).toHaveBeenCalledWith(FEATURE_NAMES.sessionReplay, 'aggregate')
-  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs)
-})
-
-test('should not import session aggregate when session is not new and a recording is not active', async () => {
-  jest.mocked(getConfigurationValue).mockReturnValue(true)
-  jest.mocked(setupAgentSession).mockReturnValue({
-    isNew: false,
-    state: {
-      sessionReplay: 0
-    }
-  })
-
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, FEATURE_NAMES.sessionReplay)
-  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  instrument.importAggregator(aggregateArgs)
-
-  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
-  await windowLoadCallback()
-
-  expect(getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled')
-  expect(setupAgentSession).toHaveBeenCalledWith(agentIdentifier)
-  expect(drain).toHaveBeenCalledWith(agentIdentifier, FEATURE_NAMES.sessionReplay)
-  expect(lazyFeatureLoader).not.toHaveBeenCalled()
-  expect(mockAggregate).not.toHaveBeenCalled()
-})
-
-test('feature still imports by default even when setupAgentSession throws an error', async () => {
-  jest.mocked(getConfigurationValue).mockReturnValue(true)
-  jest.mocked(setupAgentSession).mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
-
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
-  const aggregateArgs = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  instrument.abortHandler = jest.fn()
-  instrument.importAggregator(aggregateArgs)
-
-  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
-  await windowLoadCallback()
-
-  expect(onWindowLoad).toHaveBeenCalledWith(expect.any(Function), true)
-  expect(instrument.abortHandler).not.toHaveBeenCalled()
-  expect(warn).toHaveBeenCalledWith(expect.stringContaining('A problem occurred when starting up session manager'), expect.any(Error))
-  expect(lazyFeatureLoader).toHaveBeenCalled()
-  expect(mockAggregate).toHaveBeenCalled()
-  await expect(instrument.onAggregateImported).resolves.toBe(true)
-})
-
-test('no uncaught async exception is thrown when an import fails', async () => {
-  jest.mocked(lazyFeatureLoader).mockRejectedValue(new Error('ChunkLoadError')) // () => { throw new Error('ChunkLoadError: loading chunk xxx failed.') })
-  const mockOnError = jest.fn()
-  global.onerror = mockOnError
-
-  const instrument = new InstrumentBase(agentIdentifier, aggregator, featureName)
-  instrument.abortHandler = jest.fn()
-  instrument.importAggregator()
-
-  const windowLoadCallback = jest.mocked(onWindowLoad).mock.calls[0][0]
-  await windowLoadCallback()
-
-  expect(warn).toHaveBeenNthCalledWith(2, expect.stringContaining(`Downloading and initializing ${featureName} failed`), expect.any(Error))
-  expect(instrument.abortHandler).toHaveBeenCalled()
-  await expect(instrument.onAggregateImported).resolves.toBe(false)
-  expect(mockOnError).not.toHaveBeenCalled()
-})

package/src/features/utils/lazy-feature-loader.test.js

@@ -1,37 +0,0 @@
-import { faker } from '@faker-js/faker'
-import { FEATURE_NAMES } from '../../loaders/features/features'
-import { lazyFeatureLoader } from './lazy-feature-loader'
-
-// Use enableAutomock to make it easier to mock all the things that get imported by the aggregators
-jest.enableAutomock()
-// Unmock the file under test and the constants file
-jest.unmock('../../loaders/features/features')
-jest.unmock('./lazy-feature-loader')
-
-test.each(Object.keys(FEATURE_NAMES))('should import the aggregate for feature %s', async (key) => {
-  const featureName = FEATURE_NAMES[key]
-  const randomId = faker.datatype.uuid()
-
-  jest.setMock(`../${featureName}/aggregate`, {
-    id: randomId,
-    featureName
-  })
-
-  const result = await lazyFeatureLoader(featureName, 'aggregate')
-
-  expect(result.id).toEqual(randomId)
-  expect(result.featureName).toEqual(featureName)
-})
-
-test('should throw an error when the featureName is not supported', async () => {
-  const featureName = faker.datatype.uuid()
-
-  expect(() => lazyFeatureLoader(featureName, 'aggregate')).toThrow()
-})
-
-test('should return undefined when the featurePart is not supported', async () => {
-  const featureName = faker.datatype.uuid()
-  const featurePart = faker.datatype.uuid()
-
-  expect(lazyFeatureLoader(featureName, featurePart)).toBeUndefined()
-})

package/src/loaders/api/api.component-test.js

@@ -1,45 +0,0 @@
-import { setAPI } from './api'
-import { setInfo, getInfo, setConfiguration } from '../../common/config/config'
-
-setInfo('abcd', { licenseKey: '1234', applicationID: '1234' })
-setConfiguration('abcd', {})
-let apiInterface
-beforeEach(() => {
-  console.warn = jest.fn()
-  apiInterface = setAPI('abcd', true)
-})
-
-afterEach(() => {
-  jest.restoreAllMocks()
-})
-
-describe('api', () => {
-  describe('setApplicationVersion', () => {
-    test('setApplicationVersion sets and unsets ja with valid values', () => {
-      apiInterface.setApplicationVersion('1.2.3')
-      expect(getInfo('abcd').jsAttributes).toMatchObject({ 'application.version': '1.2.3' })
-
-      apiInterface.setApplicationVersion(null)
-      expect(getInfo('abcd').jsAttributes).toMatchObject({ })
-    })
-
-    test('setApplicationVersion warns if invalid data is supplied', () => {
-      apiInterface.setApplicationVersion(1)
-      expect(console.warn).toHaveBeenCalledWith('New Relic: Failed to execute setApplicationVersion. Expected <String | null>, but got <number>.')
-
-      apiInterface.setApplicationVersion(false)
-      expect(console.warn).toHaveBeenCalledWith('New Relic: Failed to execute setApplicationVersion. Expected <String | null>, but got <boolean>.')
-
-      apiInterface.setApplicationVersion({ version: '1.2.3' })
-      expect(console.warn).toHaveBeenCalledWith('New Relic: Failed to execute setApplicationVersion. Expected <String | null>, but got <object>.')
-    })
-
-    test('setApplicationVersion replaces existing data if called twice', () => {
-      apiInterface.setApplicationVersion('1.2.3')
-      expect(getInfo('abcd').jsAttributes).toMatchObject({ 'application.version': '1.2.3' })
-
-      apiInterface.setApplicationVersion('4.5.6')
-      expect(getInfo('abcd').jsAttributes).toMatchObject({ 'application.version': '4.5.6' })
-    })
-  })
-})

package/src/loaders/api/api.test.js

@@ -1,85 +0,0 @@
-import { setTopLevelCallers, setAPI } from './api'
-import { gosCDN } from '../../common/window/nreum'
-
-jest.enableAutomock()
-jest.unmock('./api')
-
-describe('setTopLevelCallers', () => {
-  beforeEach(() => {
-    delete gosCDN().initializedAgents
-  })
-
-  test('adds all api methods', () => {
-    setTopLevelCallers()
-
-    expect(Object.keys(gosCDN()).length).toEqual(14)
-  })
-
-  test('and runs the corresponding fn under every exposed agent', () => {
-    let newrelic = gosCDN()
-    newrelic.initializedAgents = {
-      abcd: { exposed: true, api: { noticeError: jest.fn() } },
-      efgh: { exposed: false, api: { noticeError: jest.fn() } },
-      ijkl: { exposed: true, api: { noticeError: jest.fn() } }
-    }
-
-    const someArgs = ['wtfish', { bop: 'it' }]
-    newrelic.noticeError(...someArgs)
-    expect(newrelic.initializedAgents.abcd.api.noticeError).toHaveBeenCalledWith(...someArgs)
-    expect(newrelic.initializedAgents.efgh.api.noticeError).not.toHaveBeenCalled()
-    expect(newrelic.initializedAgents.ijkl.api.noticeError).toHaveBeenCalledWith(...someArgs)
-  })
-
-  test('fn call returns right number of results based on running agent(s)', () => {
-    let newrelic = gosCDN()
-    newrelic.initializedAgents = {
-      abcd: { exposed: true, api: { interaction: jest.fn(() => 'duck') } }
-    }
-    let ret = newrelic.interaction()
-    expect(ret).toEqual('duck')
-
-    newrelic.initializedAgents.efgh = { exposed: true, api: { interaction: jest.fn(() => 'truck') } }
-    ret = newrelic.interaction()
-    expect(ret).toEqual(['duck', 'truck'])
-  })
-})
-
-jest.unmock('../../common/event-emitter/contextual-ee')
-jest.mock('../../common/constants/runtime', () => {
-  return {
-    __esModule: true,
-    isBrowserScope: false
-  }
-})
-
-describe('setAPI', () => {
-  test('also adds all api methods', () => {
-    let apiI = setAPI('abcd', true)
-
-    expect(Object.keys(apiI).length).toEqual(14)
-    for (const k of Object.keys(apiI)) { expect(apiI[k]).toBeInstanceOf(Function) }
-  })
-
-  test('sets up spa interaction api prototype/handle', () => {
-    let apiI = setAPI('abcd', true)
-    let interactionProto = Object.getPrototypeOf(apiI.interaction())
-
-    expect(Object.keys(interactionProto).length).toEqual(10)
-    for (const k of Object.keys(interactionProto)) { expect(interactionProto[k]).toBeInstanceOf(Function) }
-  })
-
-  test('calls asyncApi setAPI as well', async () => {
-    jest.resetModules()
-    let setApiCalled
-    let asyncSetApi = new Promise(resolve => { setApiCalled = resolve })
-    jest.doMock('./apiAsync', () => {
-      return {
-        __esModule: true,
-        setAPI: jest.fn(id => setApiCalled(id))
-      }
-    })
-
-    setAPI('abcd', true)
-    await expect(asyncSetApi).resolves.toBe('abcd')
-  })
-})

package/src/loaders/api/apiAsync.test.js

@@ -1,17 +0,0 @@
-import { setAPI } from './apiAsync'
-import * as register from '../../common/event-emitter/register-handler'
-
-jest.enableAutomock()
-jest.unmock('./apiAsync')
-jest.unmock('../../common/event-emitter/contextual-ee')
-
-test('setAPI registers all async methods', () => {
-  let callSpy = jest.spyOn(register, 'registerHandler')
-  setAPI('abcd')
-
-  expect(callSpy).toHaveBeenCalledTimes(5)
-  for (let i = 0; i < 5; i++) {
-    expect(callSpy.mock.calls[i][0].startsWith('api-')).toBeTruthy()
-    expect(callSpy.mock.calls[i][1]).toBeInstanceOf(Function)
-  }
-})