@newrelic/browser-agent 1.234.0 → 1.236.0

package/dist/esm/common/event-emitter/handle.test.js

@@ -1,54 +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/dist/esm/common/event-emitter/register-handler.test.js

@@ -1,51 +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])]
-  }));
-});

package/dist/esm/common/harvest/harvest-scheduler.test.js

@@ -1,37 +0,0 @@
-import { setConfiguration } from '../config/state/init';
-import { HarvestScheduler } from './harvest-scheduler';
-describe('runHarvest', () => {
-  test('should re-schedule harvest even if there is no accumulated data', () => {
-    setConfiguration('asdf', {});
-    const scheduler = new HarvestScheduler('events', {
-      getPayload: jest.fn()
-    }, {
-      agentIdentifier: 'asdf',
-      ee: {
-        on: jest.fn()
-      }
-    });
-    scheduler.started = true;
-    jest.spyOn(scheduler, 'scheduleHarvest');
-    scheduler.runHarvest();
-    expect(scheduler.opts.getPayload()).toBeFalsy();
-    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
-  });
-  test('should also re-schedule harvest if there is accumulated data', () => {
-    setConfiguration('asdf', {});
-    const scheduler = new HarvestScheduler('events', {
-      getPayload: jest.fn().mockImplementation(() => 'payload')
-    }, {
-      agentIdentifier: 'asdf',
-      ee: {
-        on: jest.fn()
-      }
-    });
-    scheduler.started = true;
-    scheduler.harvest._send = () => {};
-    jest.spyOn(scheduler, 'scheduleHarvest');
-    scheduler.runHarvest();
-    expect(scheduler.opts.getPayload()).toBeTruthy();
-    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
-  });
-});

package/dist/esm/common/harvest/harvest.test.js

@@ -1,222 +0,0 @@
-import { submitData } from '../util/submit-data';
-import { Harvest } from './harvest';
-jest.mock('../context/shared-context', () => ({
-  __esModule: true,
-  SharedContext: function () {
-    this.sharedContext = {
-      agentIdentifier: 'abcd'
-    };
-  }
-}));
-jest.mock('../config/config', () => ({
-  __esModule: true,
-  getConfigurationValue: jest.fn(),
-  getInfo: jest.fn().mockReturnValue({
-    errorBeacon: 'example.com',
-    licenseKey: 'abcd'
-  }),
-  getRuntime: jest.fn().mockReturnValue({
-    bytesSent: {},
-    queryBytesSent: {}
-  })
-}));
-jest.mock('../util/submit-data', () => ({
-  __esModule: true,
-  submitData: {
-    xhr: jest.fn(() => ({
-      addEventListener: jest.fn()
-    })),
-    beacon: jest.fn(),
-    img: jest.fn()
-  }
-}));
-describe('sendX', () => {
-  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
-    const sendCallback = jest.fn();
-    const harvester = new Harvest();
-    harvester.on('jserrors', () => ({
-      body: {},
-      qs: {}
-    }));
-    harvester.sendX({
-      endpoint: 'jserrors',
-      cbFinished: sendCallback
-    });
-    expect(sendCallback).toHaveBeenCalledWith({
-      sent: false
-    });
-    expect(submitData.xhr).not.toHaveBeenCalled();
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-  test('should send request when body is empty and sendEmptyBody is true', () => {
-    const harvester = new Harvest();
-    harvester.on('jserrors', () => ({
-      body: {},
-      qs: {}
-    }));
-    harvester.sendX({
-      endpoint: 'jserrors',
-      opts: {
-        sendEmptyBody: true
-      },
-      cbFinished: jest.fn()
-    });
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.stringContaining('https://example.com/jserrors/1/abcd?'),
-      body: undefined
-    }));
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
-    const harvester = new Harvest();
-    harvester.on('jserrors', () => ({
-      body: {
-        bar: 'foo',
-        empty: emptyValue
-      },
-      qs: {
-        foo: 'bar',
-        empty: emptyValue
-      }
-    }));
-    harvester.sendX({
-      endpoint: 'jserrors',
-      cbFinished: jest.fn()
-    });
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.stringContaining('&foo=bar'),
-      body: JSON.stringify({
-        bar: 'foo'
-      })
-    }));
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.not.stringContaining('&empty'),
-      body: expect.not.stringContaining('empty')
-    }));
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
-    const harvester = new Harvest();
-    harvester.on('jserrors', () => ({
-      body: {
-        bar: 'foo',
-        nonString: nonStringValue
-      },
-      qs: {
-        foo: 'bar',
-        nonString: nonStringValue
-      }
-    }));
-    harvester.sendX({
-      endpoint: 'jserrors',
-      cbFinished: jest.fn()
-    });
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
-      body: JSON.stringify({
-        bar: 'foo',
-        nonString: nonStringValue
-      })
-    }));
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-});
-describe('send', () => {
-  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
-    const sendCallback = jest.fn();
-    const harvester = new Harvest();
-    harvester.send({
-      endpoint: 'rum',
-      payload: {
-        qs: {},
-        body: {}
-      },
-      opts: {
-        sendEmptyBody
-      },
-      cbFinished: sendCallback
-    });
-    expect(sendCallback).toHaveBeenCalledWith({
-      sent: false
-    });
-    expect(submitData.xhr).not.toHaveBeenCalled();
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-  test('should send request when body is empty and sendEmptyBody is true', () => {
-    const harvester = new Harvest();
-    harvester.send({
-      endpoint: 'rum',
-      payload: {
-        qs: {},
-        body: {}
-      },
-      opts: {
-        sendEmptyBody: true
-      }
-    });
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.stringContaining('https://example.com/1/abcd?'),
-      body: undefined
-    }));
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
-    const harvester = new Harvest();
-    harvester.send({
-      endpoint: 'rum',
-      payload: {
-        qs: {
-          foo: 'bar',
-          empty: emptyValue
-        },
-        body: {
-          bar: 'foo',
-          empty: emptyValue
-        }
-      }
-    });
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.stringContaining('&foo=bar'),
-      body: JSON.stringify({
-        bar: 'foo'
-      })
-    }));
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.not.stringContaining('&empty'),
-      body: expect.not.stringContaining('empty')
-    }));
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
-    const harvester = new Harvest();
-    harvester.send({
-      endpoint: 'rum',
-      payload: {
-        qs: {
-          foo: 'bar',
-          nonString: nonStringValue
-        },
-        body: {
-          bar: 'foo',
-          nonString: nonStringValue
-        }
-      }
-    });
-    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
-      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
-      body: JSON.stringify({
-        bar: 'foo',
-        nonString: nonStringValue
-      })
-    }));
-    expect(submitData.img).not.toHaveBeenCalled();
-    expect(submitData.beacon).not.toHaveBeenCalled();
-  });
-});

package/dist/esm/common/ids/id.test.js

@@ -1,81 +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', _ref => {
-  let {
-    input,
-    expected
-  } = _ref;
-  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);
-});

package/dist/esm/common/ids/unique-id.test.js

@@ -1,44 +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);
-});