@newrelic/browser-agent 1.241.0 → 1.243.0

package/src/features/session_replay/aggregate/index.component-test.js

@@ -1,317 +0,0 @@
-import { Aggregate as SessionReplayAgg, AVG_COMPRESSION, MAX_PAYLOAD_SIZE, IDEAL_PAYLOAD_SIZE } from '.'
-import { Aggregator } from '../../../common/aggregate/aggregator'
-import { SESSION_EVENTS, SessionEntity, MODE } from '../../../common/session/session-entity'
-import { setConfiguration } from '../../../common/config/config'
-import { configure } from '../../../loaders/configure/configure'
-
-class LocalMemory {
-  constructor (initialState = {}) {
-    this.state = initialState
-  }
-
-  get (key) {
-    try {
-      return this.state[key]
-    } catch (err) {
-      // Error is ignored
-      return ''
-    }
-  }
-
-  set (key, value) {
-    try {
-      if (value === undefined || value === null) return this.remove(key)
-      this.state[key] = value
-    } catch (err) {
-      // Error is ignored
-    }
-  }
-
-  remove (key) {
-    try {
-      delete this.state[key]
-    } catch (err) {
-      // Error is ignored
-    }
-  }
-}
-
-let sr, session
-const agentIdentifier = 'abcd'
-const info = { licenseKey: 1234, applicationID: 9876 }
-const init = { session_replay: { enabled: true, sampling_rate: 100, error_sampling_rate: 0 } }
-
-const anyQuery = {
-  browser_monitoring_key: info.licenseKey,
-  type: 'SessionReplay',
-  app_id: Number(info.applicationID),
-  protocol_version: '0',
-  attributes: expect.any(String)
-}
-
-describe('Session Replay', () => {
-  beforeEach(async () => {
-    primeSessionAndReplay()
-  })
-  afterEach(async () => {
-    sr.abort()
-    jest.clearAllMocks()
-  })
-
-  describe('Session Replay Session Behavior', () => {
-    test('When Session Ends', async () => {
-      const xhrMockClass = () => ({
-        open: jest.fn(),
-        send: jest.fn(),
-        setRequestHeader: jest.fn(),
-        addEventListener: jest.fn()
-      })
-      global.XMLHttpRequest = jest.fn().mockImplementation(xhrMockClass)
-
-      setConfiguration(agentIdentifier, { ...init })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.initialized).toBeTruthy()
-      expect(sr.recording).toBeTruthy()
-      sr.ee.emit(SESSION_EVENTS.RESET)
-      expect(global.XMLHttpRequest).toHaveBeenCalled()
-      expect(sr.recording).toBeFalsy()
-      expect(sr.blocked).toBeTruthy()
-    })
-
-    test('When Session Is Paused/Resumed', async () => {
-      setConfiguration(agentIdentifier, { ...init })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.initialized).toBeTruthy()
-      expect(sr.recording).toBeTruthy()
-      sr.ee.emit(SESSION_EVENTS.PAUSE)
-      expect(sr.recording).toBeFalsy()
-      sr.ee.emit(SESSION_EVENTS.RESUME)
-      expect(sr.recording).toBeTruthy()
-    })
-
-    test('Session SR mode matches SR mode -- FULL', async () => {
-      setConfiguration(agentIdentifier, { ...init })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(session.state.sessionReplay).toEqual(sr.mode)
-    })
-
-    test('Session SR mode matches SR mode -- ERROR', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { sampling_rate: 0, error_sampling_rate: 100 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(session.state.sessionReplay).toEqual(sr.mode)
-    })
-
-    test('Session SR mode matches SR mode -- OFF', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { sampling_rate: 0, error_sampling_rate: 0 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(session.state.sessionReplay).toEqual(sr.mode)
-    })
-  })
-
-  describe('Session Replay Initialization Behavior', () => {
-    test('Waits for SR', async () => {
-      setConfiguration(agentIdentifier, { ...init })
-      // do not emit sr flag
-      await wait(1000)
-      expect(sr.initialized).toEqual(false)
-      expect(sr.recording).toEqual(false)
-
-      // emit a false flag
-      sr.ee.emit('rumresp-sr', [false])
-      await wait(1)
-      expect(sr.initialized).toEqual(true)
-      expect(sr.recording).toEqual(false)
-    })
-
-    test('Does not run if cookies_enabled is false', async () => {
-      setConfiguration(agentIdentifier, { ...init, privacy: { cookies_enabled: false } })
-      sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.initialized).toEqual(false)
-      expect(sr.recording).toEqual(false)
-    })
-
-    test('Does not run if session_trace is disabled', async () => {
-      setConfiguration(agentIdentifier, { ...init, session_trace: { enabled: false } })
-      sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.initialized).toEqual(false)
-      expect(sr.recording).toEqual(false)
-    })
-  })
-
-  describe('Session Replay Sample -> Mode Behaviors', () => {
-    test('New Session -- Full 1 Error 1 === FULL', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 100 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.FULL)
-    })
-
-    test('New Session -- Full 1 Error 0 === FULL', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 0, sampling_rate: 100 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.FULL)
-    })
-
-    test('New Session -- Full 0 Error 1 === ERROR', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.ERROR)
-    })
-
-    test('New Session -- Full 0 Error 0 === OFF', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 0, sampling_rate: 0 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.OFF)
-    })
-
-    test('Existing Session -- Should inherit mode from session entity and ignore samples', async () => {
-      const storage = new LocalMemory({ NRBA_SESSION: { value: 'abcdefghijklmnop', expiresAt: Date.now() + 10000, inactiveAt: Date.now() + 10000, updatedAt: Date.now(), sessionReplay: MODE.FULL, sessionTraceMode: MODE.FULL, custom: {} } })
-      session = new SessionEntity({ agentIdentifier, key: 'SESSION', storage })
-      expect(session.isNew).toBeFalsy()
-      primeSessionAndReplay(session)
-      // configure to get "error" sample ---> but should inherit FULL from session manager
-      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.FULL)
-    })
-  })
-
-  describe('Session Replay Error Mode Behaviors', () => {
-    test('An error BEFORE rrweb import starts running in FULL from beginning', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
-      sr.ee.emit('errorAgg')
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.FULL)
-      expect(sr.scheduler.started).toEqual(true)
-    })
-
-    test('An error AFTER rrweb import changes mode and starts harvester', async () => {
-      setConfiguration(agentIdentifier, { session_replay: { error_sampling_rate: 100, sampling_rate: 0 } })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.ERROR)
-      expect(sr.scheduler.started).toEqual(false)
-      sr.ee.emit('errorAgg')
-      expect(sr.mode).toEqual(MODE.FULL)
-      expect(sr.scheduler.started).toEqual(true)
-    })
-  })
-
-  describe('Session Replay Payload Validation', () => {
-    test('Payload', async () => {
-      setConfiguration(agentIdentifier, { ...init })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      const harvestContents = sr.getHarvestContents()
-      // query attrs
-      expect(harvestContents.qs).toMatchObject(anyQuery)
-
-      expect(harvestContents.body).toEqual(expect.any(Array))
-
-      expect(harvestContents.body.length).toBeGreaterThan(0)
-    })
-  })
-
-  describe('Session Replay Harvest Behaviors', () => {
-    test('Compressed payload is provided to harvester', async () => {
-      const { gunzipSync, strFromU8 } = await import('fflate')
-      setConfiguration(agentIdentifier, { ...init })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      const [harvestContents] = sr.prepareHarvest()
-      expect(harvestContents.qs).toMatchObject(anyQuery)
-      expect(harvestContents.qs.attributes.includes('content_encoding=gzip')).toEqual(true)
-      expect(harvestContents.body).toEqual(expect.any(Uint8Array))
-      expect(JSON.parse(strFromU8(gunzipSync(harvestContents.body)))).toMatchObject(expect.any(Array))
-    })
-
-    test('Uncompressed payload is provided to harvester', async () => {
-      jest.doMock('fflate', () => ({
-        __esModule: true,
-        gzipSync: jest.fn().mockImplementation(() => { throw new Error() })
-      }))
-
-      setConfiguration(agentIdentifier, { ...init })
-      sr.shouldCompress = false
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-
-      const [harvestContents] = sr.prepareHarvest()
-      expect(harvestContents.qs).toMatchObject({
-        protocol_version: '0',
-        browser_monitoring_key: info.licenseKey
-      })
-      expect(harvestContents.qs.attributes.includes('content_encoding')).toEqual(false)
-      expect(harvestContents.body).toEqual(expect.any(Array))
-    })
-
-    test('Clears the event buffer when staged for harvesting', async () => {
-      setConfiguration(agentIdentifier, { ...init })
-      sr.shouldCompress = false
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-
-      sr.prepareHarvest()
-      expect(sr.events.length).toEqual(0)
-    })
-
-    test('Harvests early if exceeds limit', async () => {
-      let after = 0
-      const spy = jest.spyOn(sr.scheduler, 'runHarvest').mockImplementation(() => { after = Date.now() })
-      setConfiguration(agentIdentifier, { ...init })
-      sr.payloadBytesEstimation = IDEAL_PAYLOAD_SIZE / AVG_COMPRESSION
-      const before = Date.now()
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(spy).toHaveBeenCalled()
-      expect(after - before).toBeLessThan(sr.harvestTimeSeconds * 1000)
-    })
-
-    test('Aborts if exceeds total limit', async () => {
-      const spy = jest.spyOn(sr.scheduler, 'runHarvest')
-      setConfiguration(agentIdentifier, { ...init })
-      sr.payloadBytesEstimation = (MAX_PAYLOAD_SIZE + 1) / AVG_COMPRESSION
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(spy).not.toHaveBeenCalled()
-      expect(sr.blocked).toEqual(true)
-      expect(sr.mode).toEqual(MODE.OFF)
-    })
-
-    test('Aborts if 429 response', async () => {
-      setConfiguration(agentIdentifier, { ...init })
-      sr.ee.emit('rumresp-sr', [true])
-      await wait(1)
-      expect(sr.mode).toEqual(MODE.FULL)
-      sr.onHarvestFinished({ status: 429 })
-      expect(sr.blocked).toEqual(true)
-      expect(sr.mode).toEqual(MODE.OFF)
-    })
-  })
-})
-
-function wait (ms = 0) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-function primeSessionAndReplay (sess = new SessionEntity({ agentIdentifier, key: 'SESSION', storage: new LocalMemory() })) {
-  session = sess
-  configure(agentIdentifier, { info, runtime: { session }, init: {} }, 'test', true)
-  sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
-}

package/src/features/spa/aggregate/interaction-node.test.js

@@ -1,17 +0,0 @@
-import { faker } from '@faker-js/faker'
-import { InteractionNode } from './interaction-node'
-
-test('finishing node with cancelled parent should not throw an error', () => {
-  const interaction = {
-    remaining: 0,
-    onNodeAdded: jest.fn(),
-    checkFinish: jest.fn()
-  }
-  const interactionRootNode = new InteractionNode(interaction, null, 'interaction', faker.date.past().getUTCSeconds())
-  const interactionNode = interactionRootNode.child('test', faker.date.past().getUTCSeconds(), 'test', false)
-
-  interactionRootNode.cancel()
-  interactionNode.finish()
-
-  expect(interactionRootNode.children.length).toEqual(0)
-})

package/src/features/utils/agent-session.test.js

@@ -1,194 +0,0 @@
-import { faker } from '@faker-js/faker'
-
-let agentIdentifier
-let agentSession
-let mockEE
-
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid()
-  mockEE = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  agentSession = {
-    state: {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    }
-  }
-
-  jest.doMock('../../common/config/config', () => ({
-    __esModule: true,
-    getConfigurationValue: jest.fn(),
-    getConfiguration: jest.fn().mockImplementation(() => ({})),
-    getInfo: jest.fn(),
-    getRuntime: jest.fn().mockImplementation(() => ({ session: agentSession })),
-    setInfo: jest.fn()
-  }))
-  jest.doMock('../../common/drain/drain', () => ({
-    __esModule: true,
-    drain: jest.fn()
-  }))
-  jest.doMock('../../common/event-emitter/contextual-ee', () => ({
-    __esModule: true,
-    ee: {
-      get: jest.fn().mockReturnValue(mockEE)
-    }
-  }))
-  jest.mock('../../common/event-emitter/register-handler', () => ({
-    __esModule: true,
-    registerHandler: jest.fn()
-  }))
-  jest.doMock('../../common/constants/runtime', () => ({
-    __esModule: true,
-    isBrowserScope: true
-  }))
-  jest.doMock('../../common/session/session-entity', () => ({
-    __esModule: true,
-    SessionEntity: jest.fn().mockReturnValue({
-      state: agentSession.state,
-      syncCustomAttribute: jest.fn()
-    })
-  }))
-  jest.doMock('../../common/storage/local-storage.js', () => ({
-    __esModule: true,
-    LocalStorage: jest.fn()
-  }))
-  jest.doMock('../../common/storage/first-party-cookies', () => ({
-    __esModule: true,
-    FirstPartyCookies: jest.fn()
-  }))
-})
-
-afterEach(() => {
-  jest.resetModules()
-})
-
-test('should register handlers and drain the session feature', async () => {
-  const { setupAgentSession } = await import('./agent-session')
-  const result = setupAgentSession(agentIdentifier)
-
-  const { registerHandler } = await import('../../common/event-emitter/register-handler')
-  const { drain } = await import('../../common/drain/drain')
-
-  expect(result).toEqual(expect.objectContaining(agentSession))
-  expect(registerHandler).toHaveBeenNthCalledWith(1, 'api-setCustomAttribute', expect.any(Function), 'session', mockEE)
-  expect(registerHandler).toHaveBeenNthCalledWith(2, 'api-setUserId', expect.any(Function), 'session', mockEE)
-  expect(drain).toHaveBeenCalledWith(agentIdentifier, 'session')
-})
-
-test('should not drain the session feature more than once', async () => {
-  const { setupAgentSession } = await import('./agent-session')
-  const result1 = setupAgentSession(agentIdentifier)
-  const result2 = setupAgentSession(agentIdentifier)
-
-  const { registerHandler } = await import('../../common/event-emitter/register-handler')
-  const { drain } = await import('../../common/drain/drain')
-
-  expect(result1).toEqual(expect.objectContaining(agentSession))
-  expect(result2).toEqual(expect.objectContaining(agentSession))
-  expect(registerHandler).toHaveBeenCalledTimes(2)
-  expect(drain).toHaveBeenCalledTimes(1)
-})
-
-test('should use the local storage class and instantiate a new session when cookies are enabled', async () => {
-  const expiresMs = faker.datatype.number()
-  const inactiveMs = faker.datatype.number()
-  const { getConfiguration } = await import('../../common/config/config')
-  jest.mocked(getConfiguration).mockReturnValue({
-    session: {
-      expiresMs,
-      inactiveMs
-    }
-  })
-
-  const { LocalStorage } = await import('../../common/storage/local-storage')
-  const { SessionEntity } = await import('../../common/session/session-entity')
-  const { setupAgentSession } = await import('./agent-session')
-  setupAgentSession(agentIdentifier)
-
-  expect(LocalStorage).toHaveBeenCalledTimes(1)
-  expect(SessionEntity).toHaveBeenCalledWith({
-    agentIdentifier,
-    key: 'SESSION',
-    storage: expect.any(LocalStorage),
-    expiresMs,
-    inactiveMs
-  })
-})
-
-test('should use the first party cookie storage class and instantiate a new session when cookies are enabled and a domain is set', async () => {
-  const expiresMs = faker.datatype.number()
-  const inactiveMs = faker.datatype.number()
-  const domain = faker.internet.domainName()
-  const { getConfiguration } = await import('../../common/config/config')
-  jest.mocked(getConfiguration).mockReturnValue({
-    session: {
-      expiresMs,
-      inactiveMs,
-      domain
-    }
-  })
-
-  const { FirstPartyCookies } = await import('../../common/storage/first-party-cookies')
-  const { SessionEntity } = await import('../../common/session/session-entity')
-  const { setupAgentSession } = await import('./agent-session')
-  setupAgentSession(agentIdentifier)
-
-  expect(FirstPartyCookies).toHaveBeenCalledTimes(1)
-  expect(SessionEntity).toHaveBeenCalledWith({
-    agentIdentifier,
-    key: 'SESSION',
-    storage: expect.any(FirstPartyCookies),
-    expiresMs,
-    inactiveMs
-  })
-})
-
-test('should set custom session data', async () => {
-  const { getInfo } = await import('../../common/config/config')
-  const agentInfo = {
-    [faker.datatype.uuid()]: faker.lorem.sentence(),
-    jsAttributes: {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    }
-  }
-  jest.mocked(getInfo).mockReturnValue(agentInfo)
-  agentSession.state.custom = {
-    [faker.datatype.uuid()]: faker.lorem.sentence()
-  }
-
-  const { setupAgentSession } = await import('./agent-session')
-  setupAgentSession(agentIdentifier)
-
-  expect(agentInfo.jsAttributes).toEqual(expect.objectContaining(agentSession.state.custom))
-})
-
-test('should not set custom session data in worker scope', async () => {
-  const globalScope = await import('../../common/constants/runtime')
-  jest.replaceProperty(globalScope, 'isBrowserScope', false)
-
-  const { setInfo } = await import('../../common/config/config')
-  const { setupAgentSession } = await import('./agent-session')
-  setupAgentSession(agentIdentifier)
-
-  expect(setInfo).not.toHaveBeenCalled()
-})
-
-test('should sync custom attributes', async () => {
-  const { registerHandler } = await import('../../common/event-emitter/register-handler')
-  agentSession.syncCustomAttribute = jest.fn()
-
-  const customProps = [
-    [faker.date.recent(), faker.datatype.uuid(), faker.lorem.sentence()],
-    [faker.date.recent(), faker.datatype.uuid(), faker.lorem.sentence()]
-  ]
-
-  const { setupAgentSession } = await import('./agent-session')
-  const retVal = setupAgentSession(agentIdentifier)
-
-  const setCustomAttributeHandler = jest.mocked(registerHandler).mock.calls[0][1]
-  const setUserIdHandler = jest.mocked(registerHandler).mock.calls[1][1]
-
-  setCustomAttributeHandler(...customProps[0])
-  setUserIdHandler(...customProps[1])
-
-  expect(retVal.syncCustomAttribute).toHaveBeenNthCalledWith(1, customProps[0][1], customProps[0][2])
-  expect(retVal.syncCustomAttribute).toHaveBeenNthCalledWith(2, customProps[1][1], customProps[1][2])
-})

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

@@ -1,123 +0,0 @@
-import { faker } from '@faker-js/faker'
-import { AggregateBase } from './aggregate-base'
-import { registerHandler } from '../../common/event-emitter/register-handler'
-import { getInfo, isConfigured, getRuntime } from '../../common/config/config'
-import { configure } from '../../loaders/configure/configure'
-import { gosCDN } from '../../common/window/nreum'
-
-jest.enableAutomock()
-jest.unmock('./aggregate-base')
-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('../../common/event-emitter/register-handler', () => ({
-  __esModule: true,
-  registerHandler: jest.fn()
-}))
-jest.mock('../../common/config/config', () => ({
-  __esModule: true,
-  getInfo: jest.fn(),
-  isConfigured: jest.fn().mockReturnValue(false),
-  getRuntime: jest.fn()
-}))
-jest.mock('../../loaders/configure/configure', () => ({
-  __esModule: true,
-  configure: jest.fn()
-}))
-jest.mock('../../common/window/nreum', () => ({
-  __esModule: true,
-  gosCDN: jest.fn().mockReturnValue({}),
-  gosNREUM: jest.fn().mockReturnValue({})
-}))
-
-let agentIdentifier
-let aggregator
-let featureName
-
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid()
-  aggregator = {}
-  featureName = faker.datatype.uuid()
-})
-
-test('should merge info, jsattributes, and runtime objects', () => {
-  const mockInfo1 = {
-    [faker.datatype.uuid()]: faker.lorem.sentence(),
-    jsAttributes: {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    }
-  }
-  jest.mocked(gosCDN).mockReturnValue({ info: mockInfo1 })
-
-  const mockInfo2 = {
-    jsAttributes: {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    }
-  }
-  jest.mocked(getInfo).mockReturnValue(mockInfo2)
-
-  const mockRuntime = {
-    [faker.datatype.uuid()]: faker.lorem.sentence()
-  }
-  jest.mocked(getRuntime).mockReturnValue(mockRuntime)
-
-  new AggregateBase(agentIdentifier, aggregator, featureName)
-
-  expect(isConfigured).toHaveBeenCalledWith(agentIdentifier)
-  expect(gosCDN).toHaveBeenCalledTimes(3)
-  expect(getInfo).toHaveBeenCalledWith(agentIdentifier)
-  expect(getRuntime).toHaveBeenCalledWith(agentIdentifier)
-  expect(configure).toHaveBeenCalledWith(agentIdentifier, {
-    info: {
-      ...mockInfo1,
-      jsAttributes: {
-        ...mockInfo1.jsAttributes,
-        ...mockInfo2.jsAttributes
-      }
-    },
-    runtime: mockRuntime
-  })
-})
-
-test('should only configure the agent once', () => {
-  jest.mocked(isConfigured).mockReturnValue(true)
-
-  new AggregateBase(agentIdentifier, aggregator, featureName)
-
-  expect(isConfigured).toHaveBeenCalledWith(agentIdentifier)
-  expect(gosCDN).not.toHaveBeenCalled()
-  expect(getInfo).not.toHaveBeenCalled()
-  expect(getRuntime).not.toHaveBeenCalled()
-  expect(configure).not.toHaveBeenCalled()
-})
-
-test('should resolve waitForFlags correctly based on flags', async () => {
-  const flagNames = [faker.datatype.uuid(), faker.datatype.uuid()]
-  const aggregateBase = new AggregateBase(agentIdentifier, aggregator, featureName)
-  aggregateBase.ee = {
-    [faker.datatype.uuid()]: faker.lorem.sentence()
-  }
-  aggregateBase.feature = {
-    [faker.datatype.uuid()]: faker.lorem.sentence()
-  }
-
-  const flagWait = aggregateBase.waitForFlags(flagNames)
-  jest.mocked(registerHandler).mock.calls[0][1](true)
-  jest.mocked(registerHandler).mock.calls[1][1](false)
-
-  expect(registerHandler).toHaveBeenCalledWith(`rumresp-${flagNames[0]}`, expect.any(Function), featureName, aggregateBase.ee)
-  expect(registerHandler).toHaveBeenCalledWith(`rumresp-${flagNames[1]}`, expect.any(Function), featureName, aggregateBase.ee)
-  await expect(flagWait).resolves.toEqual([true, false])
-})
-
-test('should not register any handlers when flagNames is empty', async () => {
-  const aggregateBase = new AggregateBase(agentIdentifier, aggregator, featureName)
-
-  await expect(aggregateBase.waitForFlags()).resolves.toEqual([])
-  expect(registerHandler).not.toHaveBeenCalled()
-})

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

@@ -1,45 +0,0 @@
-import { faker } from '@faker-js/faker'
-import { FeatureBase } from './feature-base'
-import { getRuntime } from '../../common/config/config'
-import { ee } from '../../common/event-emitter/contextual-ee'
-
-jest.enableAutomock()
-jest.unmock('./feature-base')
-jest.mock('../../common/config/config', () => ({
-  __esModule: true,
-  getRuntime: jest.fn().mockReturnValue({
-    isolatedBacklog: true
-  })
-}))
-jest.mock('../../common/event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  ee: {
-    get: jest.fn()
-  }
-}))
-
-let agentIdentifier
-let aggregator
-let featureName
-
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid()
-  aggregator = {}
-  featureName = faker.datatype.uuid()
-})
-
-it('should set instance defaults', () => {
-  const mockEE = { [faker.datatype.uuid()]: faker.lorem.sentence() }
-  jest.mocked(ee.get).mockReturnValue(mockEE)
-
-  const feature = new FeatureBase(agentIdentifier, aggregator, featureName)
-
-  expect(feature.agentIdentifier).toEqual(agentIdentifier)
-  expect(feature.aggregator).toEqual(aggregator)
-  expect(feature.featureName).toEqual(featureName)
-  expect(feature.blocked).toEqual(false)
-  expect(feature.ee).toEqual(mockEE)
-
-  expect(getRuntime).toHaveBeenCalledWith(agentIdentifier)
-  expect(ee.get).toHaveBeenCalledWith(agentIdentifier, true)
-})