@newrelic/browser-agent 1.242.0 → 1.243.1

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

@@ -1,92 +0,0 @@
-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 Ctor = jest.fn()
-  const a = {}
-
-  idFn(a)
-  Ctor.prototype = a
-
-  const b = new Ctor()
-
-  expect(b['nr@id']).toEqual(a['nr@id'])
-})
-
-test('id on prototype is different from instance', () => {
-  const Ctor = jest.fn()
-  const a = {}
-
-  idFn(a)
-  Ctor.prototype = a
-
-  const b = new Ctor()
-  const result = idFn(b)
-
-  expect(b['nr@id']).toEqual(result)
-})

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

@@ -1,58 +0,0 @@
-import crypto from 'crypto'
-import * as uniqueId from './unique-id'
-
-const getRandomValues = jest.fn(arr => crypto.randomBytes(arr.length))
-
-afterEach(() => {
-  delete global.crypto
-})
-
-describe('generateUuid', () => {
-  const uuidv4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
-
-  test('should generate a uuidv4 that matches the expected format', () => {
-    const id = uniqueId.generateUuid()
-
-    expect(uuidv4Regex.test(id)).toEqual(true)
-  })
-
-  test('should support using native crypto library', () => {
-    global.crypto = { getRandomValues }
-
-    const id = uniqueId.generateUuid()
-
-    expect(uuidv4Regex.test(id)).toEqual(true)
-    expect(getRandomValues).toHaveBeenCalledTimes(1)
-  })
-})
-
-describe('generateRandomHexString', () => {
-  const hexRegex = /^[0-9a-f]{8}$/
-
-  test('should generate a valid hex string', () => {
-    const id = uniqueId.generateRandomHexString(8)
-
-    expect(hexRegex.test(id)).toEqual(true)
-  })
-
-  test('should support using native crypto library', () => {
-    global.crypto = { getRandomValues }
-
-    const id = uniqueId.generateRandomHexString(8)
-
-    expect(hexRegex.test(id)).toEqual(true)
-    expect(getRandomValues).toHaveBeenCalledTimes(1)
-  })
-})
-
-test('generateSpanId should generate a 16 character hex string', () => {
-  const id = uniqueId.generateSpanId()
-
-  expect(/^[0-9a-f]{16}$/.test(id)).toEqual(true)
-})
-
-test('generateTraceId should generate a 32 character hex string', () => {
-  const id = uniqueId.generateTraceId()
-
-  expect(/^[0-9a-f]{32}$/.test(id)).toEqual(true)
-})

package/src/common/session/session-entity.component-test.js

@@ -1,346 +0,0 @@
-import { PREFIX } from './constants'
-import { SessionEntity } from './session-entity'
-
-const agentIdentifier = 'test_agent_identifier'
-const key = 'test_key'
-const value = 'test_value'
-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
-    }
-  }
-}
-
-jest.mock('../timer/timer')
-jest.mock('../timer/interaction-timer')
-jest.useFakeTimers()
-
-const mockBrowserScope = jest.fn().mockImplementation(() => true)
-jest.mock('../constants/runtime', () => ({
-  __esModule: true,
-  get isBrowserScope () {
-    return mockBrowserScope()
-  },
-  get globalScope () {
-    return global.window
-  }
-}))
-
-let storage
-beforeEach(() => {
-  jest.restoreAllMocks()
-  mockBrowserScope.mockReturnValue(true)
-  storage = new LocalMemory()
-})
-
-describe('constructor', () => {
-  test('must use required fields', () => {
-    try {
-      expect(new SessionEntity({})).toThrow(new Error('Missing Required Fields'))
-    } catch (err) {}
-  })
-
-  test('top-level properties are set and exposed', () => {
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    expect(session).toMatchObject({
-      agentIdentifier: expect.any(String),
-      key: expect.any(String),
-      expiresMs: expect.any(Number),
-      expiresTimer: expect.any(Object),
-      inactiveMs: expect.any(Number),
-      inactiveTimer: expect.any(Object),
-      isNew: expect.any(Boolean),
-      storage: expect.any(Object),
-      state: expect.objectContaining({
-        value: expect.any(String),
-        expiresAt: expect.any(Number),
-        inactiveAt: expect.any(Number),
-        sessionReplay: expect.any(Number),
-        sessionTraceMode: expect.any(Number)
-      })
-    })
-  })
-
-  test('can use sane defaults', () => {
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }))
-  })
-
-  test('expiresAt is the correct future timestamp - new session', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 100 })
-    expect(session.state.expiresAt).toEqual(now + 100)
-  })
-
-  test('expiresAt is the correct future timestamp - existing session', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
-    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100, storage: existingData })
-    expect(session.state.expiresAt).toEqual(now + 5000)
-  })
-
-  test('expiresAt never expires if 0', () => {
-    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 0 })
-    expect(session.state.expiresAt).toEqual(Infinity)
-  })
-
-  test('inactiveAt is the correct future timestamp - new session', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage, inactiveMs: 100 })
-    expect(session.state.inactiveAt).toEqual(now + 100)
-  })
-
-  test('inactiveAt is the correct future timestamp - existing session', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
-    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100, storage: existingData })
-    expect(session.state.inactiveAt).toEqual(now + 5000)
-  })
-
-  test('inactiveAt never expires if 0', () => {
-    const session = new SessionEntity({ agentIdentifier, key, storage, inactiveMs: 0 })
-    expect(session.state.inactiveAt).toEqual(Infinity)
-  })
-
-  test('should handle isNew', () => {
-    const newSession = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
-    expect(newSession.isNew).toBeTruthy()
-
-    const newStorage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
-    const existingSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10, storage: newStorage })
-    expect(existingSession.isNew).toBeFalsy()
-  })
-
-  test('invalid stored values sets new defaults', () => {
-    // missing required fields
-    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { invalid_fields: true } })
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }))
-  })
-
-  test('expired expiresAt value in storage sets new defaults', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now - 100, inactiveAt: Infinity } })
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }))
-  })
-
-  test('expired inactiveAt value in storage sets new defaults', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now - 100, expiresAt: Infinity } })
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }))
-  })
-})
-
-describe('reset()', () => {
-  test('should create new default values when resetting', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
-    const sessionVal = session.value
-    expect(session.state.value).toBeTruthy()
-    session.reset()
-    expect(session.state.value).toBeTruthy()
-    expect(session.state.value).not.toEqual(sessionVal)
-  })
-
-  test('custom data should be wiped on reset', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
-    session.syncCustomAttribute('test', 123)
-    expect(session.state.custom.test).toEqual(123)
-    expect(session.read().custom.test).toEqual(123)
-
-    // simulate a timer expiring
-    session.reset()
-    expect(session.state.custom?.test).toEqual(undefined)
-    expect(session.read()?.custom?.test).toEqual(undefined)
-  })
-})
-
-describe('read()', () => {
-  test('"new" sessions get data from read()', () => {
-    const newSession = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
-    expect(newSession.isNew).toBeTruthy()
-
-    expect(newSession.read()).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }))
-  })
-
-  test('"pre-existing" sessions get data from read()', () => {
-    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    expect(session.isNew).toBeFalsy()
-    expect(session.read()).toEqual(expect.objectContaining({
-      value,
-      expiresAt: Infinity,
-      inactiveAt: Infinity
-    }))
-  })
-})
-
-describe('write()', () => {
-  test('write() sets data to top-level wrapper', () => {
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    expect(session.state.value).not.toEqual(value)
-    expect(session.state.expiresAt).not.toEqual(Infinity)
-    expect(session.state.inactiveAt).not.toEqual(Infinity)
-    session.write({ ...session.state, value, expiresAt: Infinity, inactiveAt: Infinity })
-    expect(session.state.value).toEqual(value)
-    expect(session.state.expiresAt).toEqual(Infinity)
-    expect(session.state.inactiveAt).toEqual(Infinity)
-  })
-
-  test('write() sets data that read() can access', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    session.write({ ...session.state, value, expiresAt: now + 100, inactiveAt: now + 100 })
-    const read = session.read()
-    expect(read.value).toEqual(value)
-    expect(read.expiresAt).toEqual(now + 100)
-    expect(read.inactiveAt).toEqual(now + 100)
-  })
-
-  test('write() does not run with invalid data', () => {
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    let out = session.write()
-    expect(out).toEqual(undefined)
-    out = session.write('string')
-    expect(out).toEqual(undefined)
-    out = session.write(123)
-    expect(out).toEqual(undefined)
-    out = session.write(true)
-    expect(out).toEqual(undefined)
-    out = session.write(false)
-    expect(out).toEqual(undefined)
-  })
-})
-
-describe('refresh()', () => {
-  test('refresh sets inactiveAt to future time', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage, inactiveMs: 100 })
-    expect(session.state.inactiveAt).toEqual(now + 100)
-    jest.setSystemTime(now + 1000)
-    session.refresh()
-    expect(session.state.inactiveAt).toEqual(now + 100 + 1000)
-  })
-
-  test('refresh resets the entity if expiresTimer is invalid', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage, value })
-    expect(session.state.value).toEqual(value)
-    session.write({ ...session.state, expiresAt: now - 1 })
-    session.refresh()
-    expect(session.state.value).not.toEqual(value)
-  })
-
-  test('refresh resets the entity if inactiveTimer is invalid', () => {
-    const now = Date.now()
-    jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, storage, value })
-    expect(session.state.value).toEqual(value)
-    session.write({ ...session.state, inactiveAt: now - 1 })
-    session.refresh()
-    expect(session.state.value).not.toEqual(value)
-  })
-})
-
-describe('syncCustomAttribute()', () => {
-  test('Custom data can be managed by session entity', () => {
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-
-    // if custom has never been set, and a "delete" action is triggered, do nothing
-    session.syncCustomAttribute('test', null)
-    expect(session?.state?.custom?.test).toEqual(undefined)
-
-    session.syncCustomAttribute('test', 1)
-    expect(session?.state?.custom?.test).toEqual(1)
-
-    session.syncCustomAttribute('test', 'string')
-    expect(session?.state?.custom?.test).toEqual('string')
-
-    session.syncCustomAttribute('test', false)
-    expect(session?.state?.custom?.test).toEqual(false)
-
-    // null specifically deletes the object completely
-    session.syncCustomAttribute('test', null)
-    expect(session?.state?.custom?.test).toEqual(undefined)
-  })
-
-  test('Only runs in browser scope', () => {
-    mockBrowserScope.mockReturnValue(false)
-    const session = new SessionEntity({ agentIdentifier, key, storage })
-    session.syncCustomAttribute('test', 1)
-    expect(session.read().custom?.test).toEqual(undefined)
-  })
-})

package/src/common/storage/local-storage.test.js

@@ -1,17 +0,0 @@
-import { LocalStorage } from './local-storage'
-
-test('Local-memory', () => {
-  const LS = new LocalStorage()
-
-  LS.set('test', 1)
-  expect(LS.get('test')).toEqual('1')
-
-  LS.set('test')
-  expect(LS.get('test')).toEqual(undefined)
-
-  LS.set('test', 2)
-  expect(LS.get('test')).toEqual('2')
-
-  LS.remove('test')
-  expect(LS.get('test')).toEqual(undefined)
-})