@newrelic/browser-agent 1.242.0 → 1.243.0

package/src/common/url/parse-url.test.js

@@ -1,110 +0,0 @@
-afterEach(() => {
-  jest.resetModules()
-  jest.clearAllMocks()
-})
-
-const urlTests = [
-  {
-    input: 'http://example.com/path/name?qs=5&a=b',
-    expected: {
-      hostname: 'example.com',
-      pathname: '/path/name',
-      protocol: 'http',
-      port: '80',
-      sameOrigin: false
-    }
-  },
-  {
-    input: 'http://foo:bar@example.com:8080/path/@name?qs=5&a=b',
-    expected: {
-      hostname: 'example.com',
-      pathname: '/path/@name',
-      protocol: 'http',
-      port: '8080',
-      sameOrigin: false
-    }
-  },
-  {
-    input: 'https://foo:bar@example.com/path/name?qs=5&a=b',
-    expected: {
-      hostname: 'example.com',
-      pathname: '/path/name',
-      protocol: 'https',
-      port: '443',
-      sameOrigin: false
-    }
-  },
-  {
-    input: '/path/name?qs=5&a=b',
-    expected: {
-      hostname: location.hostname,
-      pathname: '/path/name',
-      protocol: location.protocol.split(':')[0],
-      port: '80',
-      sameOrigin: true
-    }
-  },
-  {
-    input: location.protocol + '//' + location.hostname + ':' + location.port + '/path/name?qs=5&a=b',
-    expected: {
-      hostname: location.hostname,
-      pathname: '/path/name',
-      protocol: location.protocol.split(':')[0],
-      port: '80',
-      sameOrigin: true
-    }
-  },
-  {
-    input: 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==',
-    expected: {
-      protocol: 'data'
-    }
-  }
-]
-
-test.each(urlTests)('verify url parsing inside browser scope', async ({ input, expected }) => {
-  jest.doMock('../constants/runtime', () => ({
-    __esModule: true,
-    isBrowserScope: true,
-    globalScope: global
-  }))
-
-  const { parseUrl } = await import('./parse-url')
-  expect(parseUrl(input)).toEqual(expected)
-})
-
-test.each(urlTests)('verify url parsing outside browser scope', async ({ input, expected }) => {
-  jest.doMock('../constants/runtime', () => ({
-    __esModule: true,
-    isBrowserScope: false,
-    globalScope: global
-  }))
-
-  const { parseUrl } = await import('./parse-url')
-  expect(parseUrl(input)).toEqual(expected)
-})
-
-test('should cache parsed urls', async () => {
-  jest.doMock('../constants/runtime', () => ({
-    __esModule: true,
-    isBrowserScope: true,
-    globalScope: global
-  }))
-
-  const input = 'http://example.com/'
-  const expected = {
-    hostname: 'example.com',
-    pathname: '/',
-    protocol: 'http',
-    port: '80',
-    sameOrigin: false
-  }
-
-  jest.spyOn(document, 'createElement')
-
-  const { parseUrl } = await import('./parse-url')
-  parseUrl(input)
-
-  expect(parseUrl(input)).toEqual(expected)
-  expect(document.createElement).toHaveBeenCalledTimes(1)
-})

package/src/common/url/protocol.test.js

@@ -1,17 +0,0 @@
-import { isFileProtocol } from './protocol'
-
-test('should return true when location url contains file protocol', () => {
-  jest.spyOn(window, 'location', 'get').mockReturnValue({
-    protocol: 'file:'
-  })
-
-  expect(isFileProtocol()).toEqual(true)
-})
-
-test('should return false when location url does not contains file protocol', () => {
-  jest.spyOn(window, 'location', 'get').mockReturnValue({
-    protocol: 'http:'
-  })
-
-  expect(isFileProtocol()).toEqual(false)
-})

package/src/common/util/console.test.js

@@ -1,34 +0,0 @@
-import { warn } from './console'
-
-beforeEach(() => {
-  console.warn = jest.fn()
-})
-
-afterEach(() => {
-  jest.restoreAllMocks()
-})
-
-describe('warn', () => {
-  test('should not call console.warn if it is not a function', () => {
-    const spy = jest.spyOn(console, 'warn')
-    console.warn = undefined
-    warn('test message')
-    expect(spy).not.toHaveBeenCalled()
-  })
-
-  test('should call console.warn with a prefixed message', () => {
-    warn('test message')
-    expect(console.warn).toHaveBeenCalledWith('New Relic: test message')
-  })
-
-  test('should call console.warn with secondary argument if provided', () => {
-    const secondary = 'secondary value'
-    warn('test message', secondary)
-    expect(console.warn).toHaveBeenCalledWith(secondary)
-  })
-
-  test('should not call console.warn with secondary argument if not provided', () => {
-    warn('test message')
-    expect(console.warn).toHaveBeenCalledTimes(1)
-  })
-})

package/src/common/util/data-size.test.js

@@ -1,56 +0,0 @@
-import { faker } from '@faker-js/faker'
-import * as stringifyModule from './stringify'
-import { dataSize } from './data-size'
-
-jest.mock('./stringify')
-
-describe('dataSize', () => {
-  test('returns length of string', () => {
-    const str = faker.lorem.sentence()
-    expect(dataSize(str)).toBe(str.length)
-  })
-
-  test('returns undefined for non-object, number, or empty string', () => {
-    expect(dataSize(Infinity)).toBeUndefined()
-    expect(dataSize(NaN)).toBeUndefined()
-    expect(dataSize(12345)).toBeUndefined()
-    expect(dataSize('')).toBeUndefined()
-  })
-
-  test('returns byte length of ArrayBuffer object', () => {
-    const buffer = new ArrayBuffer(faker.datatype.number({ min: 10, max: 100 }))
-    expect(dataSize(buffer)).toBe(buffer.byteLength)
-  })
-
-  test('returns size of Blob object', () => {
-    const blob = new Blob([faker.lorem.sentence()], { type: 'text/plain' })
-    expect(dataSize(blob)).toBe(blob.size)
-  })
-
-  test('returns undefined for FormData object', () => {
-    const formData = new FormData()
-    expect(dataSize(formData)).toBeUndefined()
-  })
-
-  test('uses stringify to get the length of an object', () => {
-    const input = {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    }
-    const expectedSize = faker.datatype.number({ min: 1000, max: 10000 })
-
-    jest.spyOn(stringifyModule, 'stringify').mockReturnValue({ length: expectedSize })
-
-    expect(dataSize(input)).toBe(expectedSize)
-  })
-
-  test('should not throw an exception if stringify throws an exception', () => {
-    const input = {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    }
-
-    jest.spyOn(stringifyModule, 'stringify').mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
-
-    expect(() => dataSize(input)).not.toThrow()
-    expect(dataSize(input)).toBeUndefined()
-  })
-})

package/src/common/util/feature-flags.test.js

@@ -1,94 +0,0 @@
-import { faker } from '@faker-js/faker'
-import * as eventEmitterModule from '../event-emitter/contextual-ee'
-import * as handleModule from '../event-emitter/handle'
-import * as drainModule from '../drain/drain'
-import { activateFeatures, activatedFeatures } from './feature-flags'
-import { FEATURE_NAMES } from '../../loaders/features/features'
-
-jest.mock('../event-emitter/handle')
-jest.mock('../drain/drain')
-jest.mock('../event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  ee: {
-    get: jest.fn(() => ({
-      foo: `bar_${Math.random()}`
-    }))
-  }
-}))
-
-let agentIdentifier
-
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid()
-})
-
-afterEach(() => {
-  Object.keys(activatedFeatures)
-    .forEach(key => delete activatedFeatures[key])
-})
-
-test.each([
-  null,
-  undefined
-])('should not do anything when flags is %s', (input) => {
-  activateFeatures(input, agentIdentifier)
-
-  expect(handleModule.handle).not.toHaveBeenCalled()
-  expect(drainModule.drain).not.toHaveBeenCalled()
-  expect(activatedFeatures).toEqual({})
-})
-
-const bucketMap = {
-  stn: [FEATURE_NAMES.sessionTrace],
-  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
-  ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa],
-  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
-}
-
-test('emits the right events when feature flag = 1', () => {
-  const flags = {}
-  Object.keys(bucketMap).forEach(flag => { flags[flag] = 1 })
-  activateFeatures(flags, agentIdentifier)
-
-  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
-
-  // each flag gets emitted to each of its mapped features, and a feat- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
-  expect(handleModule.handle).toHaveBeenCalledTimes(14)
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
-  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [true], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
-
-  Object.keys(flags).forEach(flag => { flags[flag] = true })
-  expect(activatedFeatures).toEqual(flags)
-})
-
-test('emits the right events when feature flag = 0', () => {
-  const flags = {}
-  Object.keys(bucketMap).forEach(flag => { flags[flag] = 0 })
-  activateFeatures(flags, agentIdentifier)
-
-  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
-
-  // each flag gets emitted to each of its mapped features, and a block- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
-  expect(handleModule.handle).toHaveBeenCalledTimes(14)
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'block-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
-  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [false], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
-
-  Object.keys(flags).forEach(flag => { flags[flag] = false })
-  expect(activatedFeatures).toEqual(flags)
-})
-
-test('only the first activate of the same feature is respected', () => {
-  const flags = { stn: 1 }
-  activateFeatures(flags, agentIdentifier)
-  flags.stn = 0
-  activateFeatures(flags, agentIdentifier)
-
-  const sharedEE1 = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
-  const sharedEE2 = jest.mocked(eventEmitterModule.ee.get).mock.results[1].value
-
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE1)
-  expect(handleModule.handle).toHaveBeenNthCalledWith(2, 'rumresp-stn', [true], undefined, 'session_trace', sharedEE1)
-  expect(handleModule.handle).not.toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE2)
-  expect(activatedFeatures.stn).toBeTruthy()
-})

package/src/common/util/get-or-set.test.js

@@ -1,58 +0,0 @@
-import { getOrSet } from './get-or-set'
-
-test('should return the current value of an existing property', () => {
-  const obj = { foo: 'bar' }
-  const prop = 'foo'
-  const getVal = jest.fn()
-
-  const result = getOrSet(obj, prop, getVal)
-
-  expect(result).toBe('bar')
-  expect(getVal).not.toHaveBeenCalled()
-})
-
-test('should set and return the value from getVal if the property does not exist', () => {
-  const obj = {}
-  const prop = 'foo'
-  const getVal = jest.fn().mockReturnValue('baz')
-
-  const result = getOrSet(obj, prop, getVal)
-
-  expect(result).toBe('baz')
-  expect(getVal).toHaveBeenCalled()
-  expect(obj.foo).toBe('baz')
-})
-
-test('should set the property as non-enumerable if Object.defineProperty is supported', () => {
-  const obj = {}
-  const prop = 'foo'
-  const getVal = jest.fn().mockReturnValue('baz')
-
-  jest.spyOn(Object, 'defineProperty')
-
-  const result = getOrSet(obj, prop, getVal)
-
-  expect(result).toBe('baz')
-  expect(Object.defineProperty).toHaveBeenCalledWith(obj, prop, {
-    value: 'baz',
-    writable: true,
-    enumerable: false
-  })
-})
-
-test('should set the property from getVal if Object.defineProperty and Object.keys are not supported', () => {
-  const obj = {}
-  const prop = 'foo'
-  const getVal = jest.fn(() => 'baz')
-
-  const originalFn = Object.defineProperty
-  Object.defineProperty = null
-
-  const result = getOrSet(obj, prop, getVal)
-
-  expect(result).toBe('baz')
-  expect(obj.foo).toBe('baz')
-  expect(Object.prototype.propertyIsEnumerable.call(obj, 'foo')).toBe(true)
-
-  Object.defineProperty = originalFn
-})

package/src/common/util/invoke.test.js

@@ -1,65 +0,0 @@
-import { debounce, single } from './invoke'
-
-jest.useFakeTimers()
-
-describe('debounce', () => {
-  test('should run the supplied function after 100ms', () => {
-    let mockCallback = jest.fn()
-
-    let debouncedMethod = debounce(mockCallback, 100)
-    execFnTimes(debouncedMethod, 100)
-
-    expect(mockCallback).not.toHaveBeenCalled()
-
-    jest.advanceTimersByTime(1000)
-    expect(mockCallback).toHaveBeenCalledTimes(1)
-  })
-
-  test('should rerun the supplied function when called again after 100ms', () => {
-    let mockCallback = jest.fn()
-
-    let debouncedMethod = debounce(mockCallback, 100)
-
-    execFnTimes(debouncedMethod, 100)
-    jest.advanceTimersByTime(200)
-    execFnTimes(debouncedMethod, 100)
-    jest.advanceTimersByTime(2000)
-
-    expect(mockCallback).toHaveBeenCalledTimes(2)
-  })
-
-  test('should run the supplied function on the first event and debounce subsequent events', () => {
-    let mockCallback = jest.fn()
-
-    let debouncedMethod = debounce(mockCallback, 100, { leading: true })
-
-    execFnTimes(debouncedMethod, 100)
-    expect(mockCallback).toHaveBeenCalledTimes(1)
-
-    jest.advanceTimersByTime(200)
-
-    expect(mockCallback).toHaveBeenCalledTimes(1)
-
-    execFnTimes(debouncedMethod, 100)
-    jest.advanceTimersByTime(200)
-
-    expect(mockCallback).toHaveBeenCalledTimes(2)
-  })
-})
-
-describe('single', () => {
-  test('should run the supplied function only once', () => {
-    let mockCallback = jest.fn()
-
-    let singleMethod = single(mockCallback, 100)
-    execFnTimes(singleMethod, 100)
-
-    expect(mockCallback).toHaveBeenCalledTimes(1)
-  })
-})
-
-function execFnTimes (fn, count) {
-  for (let i = 0; i < count; i++) {
-    fn()
-  }
-}

package/src/common/util/map-own.test.js

@@ -1,52 +0,0 @@
-import { mapOwn } from './map-own'
-
-test('enumerates the object properties', () => {
-  const callback = jest.fn()
-  const input = { foo: 'bar' }
-
-  mapOwn(input, callback)
-
-  expect(callback).toHaveBeenCalledWith('foo', 'bar')
-})
-
-test('return array of results from callback invocation', () => {
-  const callback = jest.fn((key, value) => `${key}:${value}`)
-  const input = { foo: 'bar', biz: 'baz' }
-
-  const result = mapOwn(input, callback)
-
-  expect(result.length).toEqual(2)
-  expect(result).toContain('foo:bar')
-  expect(result).toContain('biz:baz')
-})
-
-test('does not iterate symbol properties', () => {
-  const callback = jest.fn((key, value) => `${key}:${value}`)
-  const input = { foo: 'bar', [Symbol.for('biz')]: 'baz' }
-
-  const result = mapOwn(input, callback)
-
-  expect(result.length).toEqual(1)
-})
-
-test('does not iterate inherited properties', () => {
-  function F () {}
-  F.prototype = { biz: 'baz' }
-
-  const callback = jest.fn((key, value) => `${key}:${value}`)
-  const input = new F()
-  input.foo = 'bar'
-
-  const result = mapOwn(input, callback)
-
-  expect(result.length).toEqual(1)
-})
-
-test.each([null, undefined])('returns empty array when passed object is null or undefined', (input) => {
-  const callback = jest.fn()
-  const result = mapOwn(input, callback)
-
-  expect(Array.isArray(result)).toEqual(true)
-  expect(result.length).toEqual(0)
-  expect(callback).toHaveBeenCalledTimes(0)
-})

package/src/common/util/obfuscate.component-test.js

@@ -1,173 +0,0 @@
-import { faker } from '@faker-js/faker'
-import * as configModule from '../config/config'
-import * as urlProtocolModule from '../url/protocol'
-import * as consolModule from './console'
-import * as obfuscateModule from './obfuscate'
-
-jest.mock('../config/config')
-jest.mock('../context/shared-context')
-jest.mock('../url/protocol')
-jest.mock('./console')
-
-let agentIdentifier
-const rules = [{
-  regex: /pii/g,
-  replacement: 'OBFUSCATED'
-}]
-
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid()
-})
-
-afterEach(() => {
-  jest.resetAllMocks()
-})
-
-describe('Obfuscator', () => {
-  test('shouldObfuscate returns true when there are rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
-
-    const obfuscator = new obfuscateModule.Obfuscator()
-    obfuscator.sharedContext = { agentIdentifier }
-
-    expect(obfuscator.shouldObfuscate()).toEqual(true)
-  })
-
-  test('shouldObfuscate returns false when there are no rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([])
-
-    const obfuscator = new obfuscateModule.Obfuscator()
-    obfuscator.sharedContext = { agentIdentifier }
-
-    expect(obfuscator.shouldObfuscate()).toEqual(false)
-  })
-
-  test('obfuscateString returns the input when there are no rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([])
-
-    const input = faker.lorem.sentence()
-    const obfuscator = new obfuscateModule.Obfuscator()
-    obfuscator.sharedContext = { agentIdentifier }
-
-    expect(obfuscator.obfuscateString(input)).toEqual(input)
-  })
-
-  test('obfuscateString applies obfuscation rules to input', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
-
-    const input = 'pii'
-    const obfuscator = new obfuscateModule.Obfuscator()
-    obfuscator.sharedContext = { agentIdentifier }
-
-    expect(obfuscator.obfuscateString(input)).toEqual(rules[0].replacement)
-  })
-
-  test('obfuscateString replaces input with * when replacement is not set', () => {
-    const newRules = [{
-      regex: rules[0].regex
-    }]
-
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(newRules)
-
-    const input = 'pii'
-    const obfuscator = new obfuscateModule.Obfuscator()
-    obfuscator.sharedContext = { agentIdentifier }
-
-    expect(obfuscator.obfuscateString(input)).toEqual('*')
-  })
-
-  test.each([
-    null,
-    undefined,
-    '',
-    123
-  ])('obfuscateString returns the input it is %s', (input) => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
-
-    const obfuscator = new obfuscateModule.Obfuscator()
-    obfuscator.sharedContext = { agentIdentifier }
-
-    expect(obfuscator.obfuscateString(input)).toEqual(input)
-  })
-})
-
-describe('getRules', () => {
-  test('should return configured rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
-
-    expect(obfuscateModule.getRules()).toEqual(rules)
-  })
-
-  test('should include the file protocol obfuscation', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules)
-    jest.spyOn(urlProtocolModule, 'isFileProtocol').mockReturnValue(rules)
-
-    expect(obfuscateModule.getRules()).toEqual(expect.arrayContaining([{
-      regex: /^file:\/\/(.*)/,
-      replacement: 'file://OBFUSCATED'
-    }]))
-  })
-
-  test.each([
-    null,
-    undefined
-  ])('should return an empty array when obfuscation rules are %s', (input) => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(input)
-
-    expect(obfuscateModule.getRules()).toEqual([])
-  })
-})
-
-describe('validateRules', () => {
-  test('should return true for empty array', () => {
-    expect(obfuscateModule.validateRules([])).toEqual(true)
-  })
-
-  test('should return true for valid rules', () => {
-    expect(obfuscateModule.validateRules(rules)).toEqual(true)
-  })
-
-  test.each([
-    null,
-    123,
-    {},
-    []
-  ])('should warn about an invalid regex type %s', (input) => {
-    const newRules = [{
-      regex: input,
-      replacement: rules[0].replacement
-    }]
-
-    expect(obfuscateModule.validateRules(newRules)).toEqual(false)
-    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining(
-      'contains a "regex" value with an invalid type'
-    ))
-  })
-
-  test('should warn about a missing regex with value', () => {
-    const newRules = [{
-      replacement: rules[0].replacement
-    }]
-
-    expect(obfuscateModule.validateRules(newRules)).toEqual(false)
-    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining(
-      'missing a "regex" value'
-    ))
-  })
-
-  test.each([
-    123,
-    {},
-    []
-  ])('should warn about an invalid replacement type %s', (input) => {
-    const newRules = [{
-      regex: rules[0].regex,
-      replacement: input
-    }]
-
-    expect(obfuscateModule.validateRules(newRules)).toEqual(false)
-    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining(
-      'contains a "replacement" value with an invalid type'
-    ))
-  })
-})