npm - @newrelic/browser-agent - Versions diffs - 1.235.0 → 1.237.0 - Mend

@newrelic/browser-agent 1.235.0 → 1.237.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (389) hide show

package/dist/esm/common/util/stringify.test.js DELETED Viewed

@@ -1,46 +0,0 @@
-import { stringify } from './stringify';
-var mockEmit = jest.fn();
-jest.mock('../event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  get ee() {
-    return {
-      emit: mockEmit
-    };
-  }
-}));
-test('should return a JSON string representation of the value', () => {
-  const obj = {
-    a: 1,
-    b: {
-      nested: true
-    }
-  };
-  const expected = '{"a":1,"b":{"nested":true}}';
-  const result = stringify(obj);
-  expect(result).toBe(expected);
-});
-test('should handle circular references and exclude them from the JSON output', () => {
-  const obj = {
-    a: 1
-  };
-  obj.b = obj; // Create a circular reference
-  const expected = '{"a":1}';
-  const result = stringify(obj);
-  expect(result).toBe(expected);
-});
-test('should handle non-object values and return their string representation', () => {
-  const value = 42;
-  const expected = '42';
-  const result = stringify(value);
-  expect(result).toBe(expected);
-});
-test('should emit an "internal-error" event if an error occurs during JSON.stringify', () => {
-  const obj = {
-    a: 1
-  };
-  jest.spyOn(JSON, 'stringify').mockImplementation(() => {
-    throw new Error('message');
-  });
-  stringify(obj);
-  expect(mockEmit).toHaveBeenCalledWith('internal-error', expect.any(Array));
-});

package/dist/esm/common/util/submit-data.test.js DELETED Viewed

@@ -1,241 +0,0 @@
-/**
- * @jest-environment jsdom
- * @jest-environment-options {"html": "<html><head><script></script></head><body></body></html>", "url": "https://example.com/"}
- */
-import { faker } from '@faker-js/faker';
-import { submitData } from './submit-data';
-import * as globalScope from './global-scope';
-jest.mock('./global-scope');
-const url = 'https://example.com/api';
-afterEach(() => {
-  jest.restoreAllMocks();
-});
-describe('submitData.jsonp', () => {
-  beforeEach(() => {
-    jest.replaceProperty(globalScope, 'isWorkerScope', false);
-  });
-  afterEach(() => {
-    delete global.importScripts;
-  });
-  // This test requires a script tag to exist in the html set by this file's jest-environment-options header block.
-  test('should return an HTMLScriptElement when called from a web window environment', () => {
-    const jsonp = faker.datatype.uuid();
-    const result = submitData.jsonp({
-      url,
-      jsonp
-    });
-    expect(result).toBeInstanceOf(HTMLScriptElement);
-    expect(result.type).toBe('text/javascript');
-    expect(result.src).toBe(url + '&jsonp=' + jsonp);
-  });
-  test('should try to use importScripts when called from a worker scope', () => {
-    jest.replaceProperty(globalScope, 'isWorkerScope', true);
-    global.importScripts = jest.fn();
-    const jsonp = faker.datatype.uuid();
-    submitData.jsonp({
-      url,
-      jsonp
-    });
-    expect(global.importScripts).toHaveBeenCalledWith(url + '&jsonp=' + jsonp);
-  });
-  test('should fall back to an xhrGet call and return false when importScripts throws an error', () => {
-    jest.replaceProperty(globalScope, 'isWorkerScope', true);
-    jest.spyOn(submitData, 'xhrGet').mockImplementation(jest.fn());
-    global.importScripts = jest.fn().mockImplementation(() => {
-      throw new Error(faker.lorem.sentence());
-    });
-    const jsonp = faker.datatype.uuid();
-    const result = submitData.jsonp({
-      url,
-      jsonp
-    });
-    expect(result).toBe(false);
-    expect(global.importScripts).toHaveBeenCalledWith(url + '&jsonp=' + jsonp);
-    expect(submitData.xhrGet).toHaveBeenCalledWith({
-      url: url + '&jsonp=' + jsonp
-    });
-  });
-  test('should not throw an error when xhrGet throws an error', () => {
-    jest.replaceProperty(globalScope, 'isWorkerScope', true);
-    jest.spyOn(submitData, 'xhrGet').mockImplementation(() => {
-      throw new Error(faker.lorem.sentence());
-    });
-    global.importScripts = jest.fn().mockImplementation(() => {
-      throw new Error(faker.lorem.sentence());
-    });
-    const jsonp = faker.datatype.uuid();
-    expect(() => submitData.jsonp({
-      url,
-      jsonp
-    })).not.toThrow();
-  });
-  test('should not throw an error when element insertion fails', () => {
-    jest.spyOn(document, 'createElement').mockImplementation(() => {
-      throw new Error(faker.lorem.sentence());
-    });
-    const jsonp = faker.datatype.uuid();
-    expect(() => submitData.jsonp({
-      url,
-      jsonp
-    })).not.toThrow();
-  });
-});
-describe('submitData.xhrGet', () => {
-  test('xhrGet should call xhr with GET as the method', () => {
-    jest.spyOn(submitData, 'xhr').mockReturnValue(new XMLHttpRequest());
-    const result = submitData.xhrGet({
-      url
-    });
-    expect(result).toBeInstanceOf(XMLHttpRequest);
-    expect(submitData.xhr).toHaveBeenCalledWith({
-      url,
-      sync: false,
-      method: 'GET'
-    });
-  });
-});
-describe('submitData.xhr', () => {
-  beforeEach(() => {
-    jest.spyOn(global, 'XMLHttpRequest').mockImplementation(function () {
-      this.prototype = XMLHttpRequest.prototype;
-      this.open = jest.fn();
-      this.send = jest.fn();
-      this.setRequestHeader = jest.fn();
-      this._withCredentials = false;
-      Object.defineProperty(this, 'withCredentials', {
-        get: jest.fn(() => this._withCredentials),
-        set: jest.fn(val => this._withCredentials = val)
-      });
-    });
-  });
-  test('should make and send an xhr with default values', () => {
-    const result = submitData.xhr({
-      url
-    });
-    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0];
-    expect(result).toBeInstanceOf(XMLHttpRequest);
-    expect(result.withCredentials).toBe(true);
-    expect(xhr.open).toHaveBeenCalledWith('POST', url, true);
-    expect(xhr.setRequestHeader).toHaveBeenCalledWith('content-type', 'text/plain');
-    expect(xhr.send).toHaveBeenCalledWith(null);
-  });
-  test('should send the body when provided', () => {
-    const body = faker.lorem.paragraph();
-    submitData.xhr({
-      url,
-      body
-    });
-    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0];
-    expect(xhr.send).toHaveBeenCalledWith(body);
-  });
-  test('should set async to false', () => {
-    submitData.xhr({
-      url,
-      sync: true
-    });
-    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0];
-    expect(xhr.open).toHaveBeenCalledWith('POST', url, false);
-  });
-  test('should use the provided method', () => {
-    submitData.xhr({
-      url,
-      method: 'HEAD'
-    });
-    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0];
-    expect(xhr.open).toHaveBeenCalledWith('HEAD', url, true);
-  });
-  test('should use the provided headers', () => {
-    const headers = [{
-      key: faker.lorem.word(),
-      value: faker.datatype.uuid()
-    }];
-    submitData.xhr({
-      url,
-      headers
-    });
-    const xhr = jest.mocked(global.XMLHttpRequest).mock.instances[0];
-    expect(xhr.setRequestHeader).not.toHaveBeenCalledWith('content-type', 'text/plain');
-    expect(xhr.setRequestHeader).toHaveBeenCalledWith(headers[0].key, headers[0].value);
-  });
-  test('should not throw an error if withCredentials is not supported', () => {
-    jest.spyOn(global, 'XMLHttpRequest').mockImplementation(function () {
-      this.prototype = XMLHttpRequest.prototype;
-      this.open = jest.fn();
-      this.send = jest.fn();
-      this.setRequestHeader = jest.fn();
-    });
-    expect(() => submitData.xhr({
-      url
-    })).not.toThrow();
-  });
-  test('should not throw an error if setRequestHeader throws an error', () => {
-    jest.spyOn(global, 'XMLHttpRequest').mockImplementation(function () {
-      this.prototype = XMLHttpRequest.prototype;
-      this.open = jest.fn();
-      this.send = jest.fn();
-      this.setRequestHeader = jest.fn();
-      Object.defineProperty(this, 'withCredentials', {
-        get: jest.fn().mockImplementation(() => {
-          throw new Error(faker.lorem.sentence());
-        }),
-        set: jest.fn().mockImplementation(() => {
-          throw new Error(faker.lorem.sentence());
-        })
-      });
-    });
-    expect(() => submitData.xhr({
-      url
-    })).not.toThrow();
-  });
-});
-describe('submitData.img', () => {
-  test('should return an HTMLImageElement', () => {
-    const imageUrl = 'https://example.com/image.png';
-    const result = submitData.img({
-      url: imageUrl
-    });
-    expect(result).toBeInstanceOf(HTMLImageElement);
-    expect(result.src).toBe(imageUrl);
-  });
-});
-describe('submitData.beacon', () => {
-  afterEach(() => {
-    delete window.navigator.sendBeacon;
-  });
-  test('should return true when beacon request succeeds', () => {
-    window.navigator.sendBeacon = jest.fn().mockReturnValue(true);
-    const body = faker.lorem.paragraph();
-    const result = submitData.beacon({
-      url,
-      body
-    });
-    expect(result).toBe(true);
-    expect(window.navigator.sendBeacon).toHaveBeenCalledWith(url, body);
-  });
-  test('should return false when beacon request returns false', () => {
-    window.navigator.sendBeacon = jest.fn().mockReturnValue(false);
-    const result = submitData.beacon({
-      url
-    });
-    expect(result).toBe(false);
-  });
-  test('should return false when beacon request throws an error', () => {
-    window.navigator.sendBeacon = jest.fn(() => {
-      throw new Error(faker.lorem.sentence());
-    });
-    const result = submitData.beacon({
-      url
-    });
-    expect(result).toBe(false);
-  });
-  test('should always bind window.navigator to the sendBeacon function', () => {
-    window.navigator.sendBeacon = jest.fn().mockReturnValue(true);
-    window.navigator.sendBeacon.bind = jest.fn(() => {});
-    submitData.beacon({
-      url
-    });
-    expect(window.navigator.sendBeacon.bind).toHaveBeenCalledWith(window.navigator);
-  });
-});

package/dist/esm/common/util/traverse.test.js DELETED Viewed

@@ -1,42 +0,0 @@
-import { applyFnToProps } from './traverse';
-test.each(['not an object', null, undefined])('should return input unchanged when input is %p', input => {
-  const result = applyFnToProps(input, jest.fn());
-  expect(result).toEqual(input);
-});
-test('should apply the provided function only to properties of the specified type', () => {
-  const obj = {
-    stringProp: 'Hello',
-    numberProp: 42,
-    arrayProp: [1, 2, 3],
-    objectProp: {
-      foo: 'bar'
-    }
-  };
-  const fn = jest.fn(value => value.toUpperCase());
-  const result = applyFnToProps(obj, fn, 'string');
-  expect(result.stringProp).toBe('HELLO');
-  expect(result.numberProp).toBe(42);
-  expect(result.arrayProp).toEqual([1, 2, 3]);
-  expect(result.objectProp).toEqual({
-    foo: 'BAR'
-  });
-  expect(fn).toHaveBeenCalledTimes(2);
-  expect(fn).toHaveBeenCalledWith('Hello');
-  expect(fn).toHaveBeenCalledWith('bar');
-});
-test('should ignore properties specified in ignoreKeys', () => {
-  const obj = {
-    a: 1,
-    b: 2,
-    c: 3
-  };
-  const fn = jest.fn(value => value + 1);
-  const ignoreKeys = ['c'];
-  const result = applyFnToProps(obj, fn, 'number', ignoreKeys);
-  expect(result.a).toBe(2);
-  expect(result.b).toBe(3);
-  expect(result.c).toBe(3);
-  expect(fn).toHaveBeenCalledTimes(2);
-  expect(fn).toHaveBeenCalledWith(1);
-  expect(fn).toHaveBeenCalledWith(2);
-});

package/dist/esm/common/wrap/wrap-promise.test.js DELETED Viewed

@@ -1,115 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { globalScope } from '../util/global-scope';
-import { originals } from '../config/config';
-jest.mock('./wrap-function', () => ({
-  __esModule: true,
-  createWrapperWithEmitter: jest.fn(() => fn => function () {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return fn.apply(null, args);
-  })
-}));
-jest.mock('../event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  getOrSetContext: jest.fn(() => ({})),
-  ee: {
-    get: jest.fn(name => ({
-      debugId: name,
-      on: jest.fn(),
-      context: jest.fn(() => ({})),
-      emit: jest.fn()
-    }))
-  }
-}));
-jest.mock('../config/config', () => ({
-  __esModule: true,
-  originals: {}
-}));
-jest.mock('../util/global-scope', () => ({
-  __esModule: true,
-  globalScope: {
-    NREUM: {}
-  }
-}));
-let promiseConstructorCalls;
-beforeEach(async () => {
-  promiseConstructorCalls = [];
-  // Proxy the global Promise to prevent the wrapping from
-  // messing with Jest internal promises
-  originals.PR = new Proxy(class extends Promise {}, {
-    construct(target, args) {
-      promiseConstructorCalls.push(args);
-      return Reflect.construct(target, args);
-    }
-  });
-  (await import('./wrap-promise')).wrapPromise();
-});
-afterEach(() => {
-  jest.resetModules();
-});
-test('should wrap promise constructor', async () => {
-  const promiseInstance = new globalScope.Promise(jest.fn());
-  expect(promiseInstance).toBeInstanceOf(Promise);
-  expect(promiseConstructorCalls.length).toEqual(1);
-  expect(globalScope.Promise.toString()).toMatch(/\[native code\]/);
-  expect(globalScope.Promise.name).toEqual('Promise');
-});
-describe('all', () => {
-  test('should work with acceptable iterables', async () => {
-    const resolveValue = faker.datatype.uuid();
-    const customIterable = new CustomIterable([new globalScope.Promise(resolve => resolve(resolveValue))]);
-    const arrayIterable = [new globalScope.Promise(resolve => resolve(resolveValue))];
-    const setIterable = new Set();
-    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)));
-    await expect(globalScope.Promise.all(customIterable)).resolves.toEqual([resolveValue]);
-    await expect(globalScope.Promise.all(arrayIterable)).resolves.toEqual([resolveValue]);
-    await expect(globalScope.Promise.all(setIterable)).resolves.toEqual([resolveValue]);
-  });
-  test.each([null, undefined])('should not try to iterate a non-iterable %s', async input => {
-    jest.spyOn(globalScope.Promise, 'resolve');
-    await expect(globalScope.Promise.all(input)).rejects.toThrow();
-    expect(globalScope.Promise.resolve).not.toHaveBeenCalled();
-  });
-});
-describe('race', () => {
-  test('should work with acceptable iterables', async () => {
-    jest.spyOn(globalScope.Promise, 'resolve');
-    const resolveValue = faker.datatype.uuid();
-    const customIterable = new CustomIterable([new globalScope.Promise(resolve => resolve(resolveValue))]);
-    const arrayIterable = [new globalScope.Promise(resolve => resolve(resolveValue))];
-    const setIterable = new Set();
-    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)));
-    await expect(globalScope.Promise.race(customIterable)).resolves.toEqual(resolveValue);
-    await expect(globalScope.Promise.race(arrayIterable)).resolves.toEqual(resolveValue);
-    await expect(globalScope.Promise.race(setIterable)).resolves.toEqual(resolveValue);
-    expect(globalScope.Promise.resolve).toHaveBeenCalled();
-  });
-  test.each([null, undefined])('should not try to iterate a non-iterable %s', async input => {
-    jest.spyOn(globalScope.Promise, 'resolve');
-    await expect(globalScope.Promise.race(input)).rejects.toThrow();
-    expect(globalScope.Promise.resolve).not.toHaveBeenCalled();
-  });
-});
-class CustomIterable {
-  #iterables = [];
-  constructor(iterables) {
-    this.#iterables = iterables;
-  }
-  [Symbol.iterator]() {
-    return {
-      index: 0,
-      iterables: this.#iterables,
-      next() {
-        return {
-          done: this.index >= this.iterables.length,
-          value: this.iterables[this.index++] || undefined
-        };
-      },
-      [Symbol.iterator]() {
-        return this;
-      }
-    };
-  }
-}

package/dist/esm/features/jserrors/aggregate/canonical-function-name.test.js DELETED Viewed

@@ -1,29 +0,0 @@
-import { canonicalFunctionName } from './canonical-function-name';
-test.each([{
-  input: null,
-  expected: undefined,
-  title: 'Return undefined if no function name'
-}, {
-  input: 'test',
-  expected: 'test',
-  title: 'Simple function name'
-}, {
-  input: 'scope1/scope2/func',
-  expected: 'func',
-  title: 'Remove Firefox scopes'
-}, {
-  input: 'scope1.func',
-  expected: 'func',
-  title: 'Remove Chrome scopes'
-}, {
-  input: '<anonymous>',
-  expected: undefined,
-  title: 'Return undefined ending is non-alphanumeric'
-}])('$title', _ref => {
-  let {
-    input,
-    expected
-  } = _ref;
-  const result = canonicalFunctionName(input);
-  expect(result).toEqual(expected);
-});