@newrelic/browser-agent 1.235.0 → 1.236.0

package/dist/esm/common/event-emitter/contextual-ee.test.js

@@ -1,278 +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 returns the event-emitter defined on window.NREUM', async () => {
-    const mockEE = {};
-    mockNREUM.ee = mockEE;
-    const {
-      ee
-    } = await import('./contextual-ee');
-    expect(ee).toEqual(mockEE);
-  });
-  test('it sets the global event-emitter on window.NREUM', async () => {
-    const {
-      ee
-    } = await import('./contextual-ee');
-    expect(ee).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({});
-  });
-  test('it returns the same context', async () => {
-    const {
-      ee
-    } = await import('./contextual-ee');
-    const result = ee.context();
-    expect(result).toEqual(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);
-    expect(result).toEqual(obj['nr@context']);
-  });
-});
-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(ee.backlog.feature).toEqual(scopeEE.backlog.feature);
-  });
-});
-describe('getOrSetContext', () => {
-  test('it returns a new context', async () => {
-    const {
-      getOrSetContext
-    } = await import('./contextual-ee');
-    const obj = {};
-    const result = getOrSetContext(obj);
-    expect(result).toEqual({});
-    expect(result).toEqual(obj['nr@context']);
-  });
-  test('it returns the same context', async () => {
-    const {
-      getOrSetContext
-    } = await import('./contextual-ee');
-    const obj = {};
-    const result = getOrSetContext(obj);
-    expect(getOrSetContext(obj)).toEqual(result);
-  });
-});

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.component-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.component-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();
-  });
-});