@newrelic/browser-agent 0.1.230 → 0.1.231

package/src/common/event-emitter/contextual-ee.test.js

@@ -0,0 +1,310 @@
+import { faker } from '@faker-js/faker'
+
+let mockNREUM
+let runtime
+
+beforeEach(() => {
+  mockNREUM = {}
+  runtime = {}
+
+  jest.doMock('../window/nreum', () => ({
+    __esModule: true,
+    gosNREUM: jest.fn(() => mockNREUM)
+  }))
+
+  jest.doMock('../config/config', () => ({
+    __esModule: true,
+    getRuntime: jest.fn(() => runtime)
+  }))
+})
+
+afterEach(() => {
+  jest.resetModules()
+  jest.resetAllMocks()
+})
+
+describe('global event-emitter', () => {
+  test('it returns the event-emitter defined on window.NREUM', async () => {
+    const mockEE = {}
+    mockNREUM.ee = mockEE
+
+    const { ee } = await import('./contextual-ee')
+
+    expect(ee).toEqual(mockEE)
+  })
+
+  test('it sets the global event-emitter on window.NREUM', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    expect(ee).toEqual(mockNREUM.ee)
+  })
+})
+
+describe('scoping event-emitter', () => {
+  test('it creates a new child event-emitter', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const childName = faker.datatype.uuid()
+    const result = ee.get(childName)
+
+    expect(result).not.toEqual(mockNREUM.ee)
+    expect(result).toEqual(ee.get(childName)) // Should always return the same event-emitter
+    expect(result.debugId).toEqual(childName)
+  })
+
+  test('it creates a child event-emitter with an isolated backlog', async () => {
+    const childName = faker.random.alphaNumeric(16)
+
+    jest.doMock('../config/config', () => ({
+      __esModule: true,
+      getRuntime: jest.fn(id => {
+        if (id === childName) {
+          return { isolatedBacklog: true }
+        }
+
+        return runtime
+      })
+    }))
+
+    const { ee } = await import('./contextual-ee')
+    const result = ee.get(childName)
+
+    expect(ee.backlog).not.toBe(result.backlog)
+  })
+})
+
+describe('event-emitter context', () => {
+  test('it returns a new context', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const result = ee.context()
+
+    expect(result).toEqual({})
+  })
+
+  test('it returns the same context', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const result = ee.context()
+
+    expect(result).toEqual(ee.context(result))
+  })
+
+  test('it adds the context to the provided object', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    const obj = {}
+    const result = ee.context(obj)
+
+    expect(result).toEqual(obj['nr@context'])
+  })
+})
+
+describe('event-emitter buffer', () => {
+  it('it should create a new buffer for the given group', async () => {
+    const { ee } = await import('./contextual-ee')
+    const eventType = faker.datatype.uuid()
+    const group = faker.datatype.uuid()
+
+    ee.buffer([eventType], group)
+
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      [group]: []
+    }))
+    expect(ee.isBuffering(eventType)).toEqual(true)
+  })
+
+  it('it should default group to "feature"', async () => {
+    const { ee } = await import('./contextual-ee')
+    const eventType = faker.datatype.uuid()
+
+    ee.buffer([eventType])
+
+    expect(ee.backlog).toEqual(expect.objectContaining({
+      feature: []
+    }))
+    expect(ee.isBuffering(eventType)).toEqual(true)
+  })
+
+  it('it should not create buffer if event-emitter is aborted', async () => {
+    const { ee } = await import('./contextual-ee')
+    const eventType = faker.datatype.uuid()
+    const group = faker.datatype.uuid()
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+    ee.buffer([eventType], group)
+
+    expect(ee.backlog).toEqual({})
+    expect(ee.isBuffering(eventType)).toEqual(false)
+  })
+})
+
+describe('event-emitter abort', () => {
+  test('it aborts if there is an API backlog', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+
+    expect(ee.aborted).toEqual(true)
+    expect(ee.backlog).toEqual({})
+  })
+
+  test('it aborts if there is a feature backlog', async () => {
+    const { ee } = await import('./contextual-ee')
+
+    ee.backlog = {
+      feature: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+
+    expect(ee.aborted).toEqual(true)
+    expect(ee.backlog).toEqual({})
+  })
+})
+
+describe('event-emitter emit', () => {
+  it('should execute the listener', async () => {
+    const { ee } = await import('./contextual-ee')
+    const mockListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+
+    expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2])
+  })
+
+  it('should not execute the listener after removal', async () => {
+    const { ee } = await import('./contextual-ee')
+    const mockListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+    ee.removeEventListener(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+
+    expect(mockListener).toHaveBeenCalledTimes(1)
+  })
+
+  it('should return early if global event-emitter is aborted', async () => {
+    const { ee } = await import('./contextual-ee')
+    const mockListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+    ee.on(eventType, mockListener)
+    ee.emit(eventType, eventArgs)
+
+    expect(mockListener).toHaveBeenCalledTimes(0)
+  })
+
+  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.backlog = {
+      api: ['foo', 'bar', 'baz']
+    }
+    ee.abort()
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.emit(eventType, eventArgs, {}, true)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+  })
+
+  it('should bubble the event if bubble flag is true', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockListener = jest.fn()
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.emit(eventType, eventArgs, {}, false, true)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).toHaveBeenCalledTimes(1)
+  })
+
+  it('should not bubble the event if bubble flag is false', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockListener = jest.fn()
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.emit(eventType, eventArgs, {}, false, false)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).not.toHaveBeenCalled()
+  })
+
+  it('should buffer the event on the scoped event-emitter', async () => {
+    const { ee } = await import('./contextual-ee')
+    const scopeEE = ee.get(faker.datatype.uuid())
+    const mockListener = jest.fn()
+    const mockScopeListener = jest.fn()
+    const eventType = faker.datatype.uuid()
+    const eventArgs = ['a', 'b', 'c']
+
+    ee.on(eventType, mockListener)
+    ee.buffer([eventType])
+    scopeEE.on(eventType, mockScopeListener)
+    scopeEE.buffer([eventType])
+    scopeEE.emit(eventType, eventArgs, {}, false, false)
+
+    expect(mockScopeListener).toHaveBeenCalledTimes(1)
+    expect(mockListener).not.toHaveBeenCalled()
+    expect(scopeEE.backlog['feature']).toEqual(expect.arrayContaining([
+      expect.arrayContaining([
+        scopeEE,
+        eventType,
+        eventArgs,
+        {}
+      ])
+    ]))
+    expect(ee.backlog['feature']).toEqual(scopeEE.backlog['feature'])
+  })
+})
+
+describe('getOrSetContext', () => {
+  test('it returns a new context', async () => {
+    const { getOrSetContext } = await import('./contextual-ee')
+
+    const obj = {}
+    const result = getOrSetContext(obj)
+
+    expect(result).toEqual({})
+    expect(result).toEqual(obj['nr@context'])
+  })
+
+  test('it returns the same context', async () => {
+    const { getOrSetContext } = await import('./contextual-ee')
+
+    const obj = {}
+    const result = getOrSetContext(obj)
+
+    expect(getOrSetContext(obj)).toEqual(result)
+  })
+})

package/src/common/event-emitter/handle.test.js

@@ -0,0 +1,56 @@
+import { faker } from '@faker-js/faker'
+
+jest.mock('./contextual-ee', () => ({
+  __esModule: true,
+  ee: {
+    buffer: jest.fn(),
+    emit: jest.fn(),
+    get: jest.fn(() => ({
+      buffer: jest.fn(),
+      emit: jest.fn()
+    }))
+  }
+}))
+
+afterEach(() => {
+  jest.resetModules()
+  jest.resetAllMocks()
+})
+
+test('it should create and use a default event-emitter', async () => {
+  const { ee } = await import('./contextual-ee')
+  const { handle } = await import('./handle')
+
+  const handleEE = jest.mocked(ee.get).mock.results[0].value
+  const eventType = faker.datatype.uuid()
+  const eventArgs = ['a', 'b', 'c']
+  const eventContext = {}
+  const eventGroup = faker.datatype.uuid()
+
+  handle(eventType, eventArgs, eventContext, eventGroup)
+
+  expect(handleEE.buffer).toHaveBeenCalledWith([eventType], eventGroup)
+  expect(handleEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext)
+})
+
+test('it should use the provided scoped event-emitter', async () => {
+  const { ee } = await import('./contextual-ee')
+  const { handle } = await import('./handle')
+  const scopedEE = {
+    buffer: jest.fn(),
+    emit: jest.fn()
+  }
+
+  const handleEE = jest.mocked(ee.get).mock.results[0].value
+  const eventType = faker.datatype.uuid()
+  const eventArgs = ['a', 'b', 'c']
+  const eventContext = {}
+  const eventGroup = faker.datatype.uuid()
+
+  handle(eventType, eventArgs, eventContext, eventGroup, scopedEE)
+
+  expect(handleEE.buffer).not.toHaveBeenCalled()
+  expect(handleEE.emit).not.toHaveBeenCalled()
+  expect(scopedEE.buffer).toHaveBeenCalledWith([eventType], eventGroup)
+  expect(scopedEE.emit).toHaveBeenCalledWith(eventType, eventArgs, eventContext)
+})

package/src/common/event-emitter/register-handler.test.js

@@ -0,0 +1,61 @@
+import { faker } from '@faker-js/faker'
+
+jest.mock('./handle', () => ({
+  __esModule: true,
+  handleEE: {}
+}))
+
+afterEach(() => {
+  jest.resetModules()
+  jest.resetAllMocks()
+})
+
+test('should default group to "feature"', async () => {
+  const { handleEE } = await import('./handle')
+  const { registerHandler } = await import('./register-handler')
+
+  const eventType = faker.datatype.uuid()
+  const eventHandler = jest.fn()
+
+  registerHandler(eventType, eventHandler)
+
+  expect(registerHandler.handlers['feature']).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([
+      handleEE, eventHandler
+    ])]
+  }))
+})
+
+test('should use the provided group', async () => {
+  const { handleEE } = await import('./handle')
+  const { registerHandler } = await import('./register-handler')
+
+  const eventType = faker.datatype.uuid()
+  const eventGroup = faker.datatype.uuid()
+  const eventHandler = jest.fn()
+
+  registerHandler(eventType, eventHandler, eventGroup)
+
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([
+      handleEE, eventHandler
+    ])]
+  }))
+})
+
+test('should use the provided event-emitter', async () => {
+  const { registerHandler } = await import('./register-handler')
+
+  const scopedEE = {}
+  const eventType = faker.datatype.uuid()
+  const eventGroup = faker.datatype.uuid()
+  const eventHandler = jest.fn()
+
+  registerHandler(eventType, eventHandler, eventGroup, scopedEE)
+
+  expect(registerHandler.handlers[eventGroup]).toEqual(expect.objectContaining({
+    [eventType]: [expect.arrayContaining([
+      scopedEE, eventHandler
+    ])]
+  }))
+})

package/src/common/harvest/harvest.js

@@ -15,7 +15,7 @@ import { eventListenerOpts } from '../event-listener/event-listener-opts'
 import { Obfuscator } from '../util/obfuscate'
 import { applyFnToProps } from '../util/traverse'
 import { SharedContext } from '../context/shared-context'
-import { VERSION } from '../constants/environment-variables'
+import { VERSION } from '../constants/env'
 import { isBrowserScope, isWorkerScope } from '../util/global-scope'
 
 const haveSendBeacon = !!navigator.sendBeacon // only the web window obj has sendBeacon at this time, so 'false' for other envs
@@ -176,7 +176,7 @@ export class Harvest extends SharedContext {
   createPayload (type, options) {
     var makeBody = createAccumulator()
     var makeQueryString = createAccumulator()
-    var listeners = (this._events[type] && this._events[type] || [])
+    var listeners = ((this._events[type] && this._events[type]) || [])
 
     for (var i = 0; i < listeners.length; i++) {
       var singlePayload = listeners[i](options)

package/src/common/ids/id.js

@@ -3,17 +3,26 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
-// actually setting it (which would create a global variable).
 import { getOrSet } from '../util/get-or-set'
 import { globalScope } from '../util/global-scope'
 
-var index = 1
-var prop = 'nr@id'
+// Start assigning ids at 1 so 0 can always be used for Window or WorkerGlobalScope, without
+// actually setting it (which would create a global variable).
+let index = 1
+const prop = 'nr@id'
 
-// Always returns id of obj, may tag obj with an id in the process.
+/**
+ * Tags a specified object with an identifier if it does not already
+ * have one. If the object is the global scope, zero will be returned
+ * and the object will not be modified. If the object already contains
+ * an identifier, it will be returned without modification. If the passed
+ * value is not an object, function, or array, -1 will be returned without
+ * modifying the passed value.
+ * @param {object|function|array} obj Object to be tagged with an identifier
+ * @returns {number} Identifier of the given object
+ */
 export function id (obj) {
-  var type = typeof obj
+  const type = typeof obj
   // We can only tag objects, functions, and arrays with ids.
   // For all primitive values we instead return -1.
   if (!obj || !(type === 'object' || type === 'function')) return -1

package/src/common/ids/id.test.js

@@ -0,0 +1,92 @@
+let idFn
+
+beforeEach(async () => {
+  idFn = (await import('./id')).id
+})
+
+afterEach(() => {
+  jest.resetModules()
+  jest.clearAllMocks()
+})
+
+test.each([
+  { input: undefined, expected: -1, title: 'id of undefined is -1' },
+  { input: null, expected: -1, title: 'id of null is -1' },
+  { input: 2, expected: -1, title: 'id of number is -1' },
+  { input: 'foo', expected: -1, title: 'id of string is -1' }
+])('$title', ({ input, expected }) => {
+  const result = idFn(input)
+
+  expect(typeof result).toEqual('number')
+  expect(result).toEqual(expected)
+})
+
+test('id values increment sequentially', () => {
+  const inputA = {}
+  const inputB = {}
+
+  const resultA = idFn(inputA)
+  const resultB = idFn(inputB)
+
+  expect(resultA - resultB).toEqual(-1)
+})
+
+test('id is correctly assigned to function type', () => {
+  const input = jest.fn()
+
+  const result = idFn(input)
+
+  expect(result).toEqual(1)
+  expect(input['nr@id']).toEqual(1)
+})
+
+test('id is correctly assigned to object type', () => {
+  const input = {}
+
+  const result = idFn(input)
+
+  expect(result).toEqual(1)
+  expect(input['nr@id']).toEqual(1)
+})
+
+test('id is the same when called twice on the same input', () => {
+  const input = {}
+
+  const result1 = idFn(input)
+  const result2 = idFn(input)
+
+  expect(result1).toEqual(1)
+  expect(result2).toEqual(1)
+  expect(input['nr@id']).toEqual(1)
+})
+
+test('id is zero on global scope', async () => {
+  const result = idFn(global)
+
+  expect(result).toEqual(0)
+})
+
+test('id on prototype is correctly inherited', () => {
+  const fn = jest.fn()
+  const a = {}
+
+  idFn(a)
+  fn.prototype = a
+
+  const b = new fn()
+
+  expect(b['nr@id']).toEqual(a['nr@id'])
+})
+
+test('id on prototype is different from instance', () => {
+  const fn = jest.fn()
+  const a = {}
+
+  idFn(a)
+  fn.prototype = a
+
+  const b = new fn()
+  const result = idFn(b)
+
+  expect(b['nr@id']).toEqual(result)
+})