@newrelic/browser-agent 1.241.0 → 1.243.0

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

@@ -1,293 +0,0 @@
-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 sets the global event-emitter on window.NREUM when it does not already exist', async () => {
-    const { ee } = await import('./contextual-ee')
-
-    expect(ee).toEqual(mockNREUM.ee)
-  })
-
-  test('it does not set the global event-emitter on window.NREUM when it already exists', async () => {
-    mockNREUM.ee = {}
-
-    const { ee } = await import('./contextual-ee')
-
-    expect(ee).not.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(expect.objectContaining({
-      contextId: expect.stringContaining('nr@context:')
-    }))
-  })
-
-  test('it returns the same context', async () => {
-    const { ee } = await import('./contextual-ee')
-
-    const result = ee.context()
-
-    expect(result).toBe(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)
-    const ctxKey = Object.getOwnPropertyNames(obj).find(k => k.startsWith('nr@context'))
-
-    expect(result).toBe(obj[ctxKey])
-  })
-})
-
-describe('event-emitter buffer', () => {
-  test('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)
-  })
-
-  test('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)
-  })
-
-  test('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', () => {
-  test('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])
-  })
-
-  test('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)
-  })
-
-  test('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)
-  })
-
-  test('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)
-  })
-
-  test('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)
-  })
-
-  test('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()
-  })
-
-  test('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.objectContaining({
-          contextId: expect.stringContaining('nr@context:')
-        })
-      ])
-    ]))
-    expect(ee.backlog.feature).toEqual(scopeEE.backlog.feature)
-  })
-})

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

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

@@ -1,61 +0,0 @@
-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
-    ])]
-  }))
-})