@newrelic/browser-agent 1.235.0 → 1.236.0

package/dist/esm/common/timer/interaction-timer.component-test.js

@@ -1,214 +0,0 @@
-import { InteractionTimer } from './interaction-timer';
-jest.useFakeTimers();
-let now;
-beforeEach(() => {
-  now = Date.now();
-  jest.setSystemTime(now);
-});
-afterEach(() => {
-  jest.clearAllMocks();
-});
-describe('constructor', () => {
-  test('appropriate properties are set with valid values -- no refresh', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
-    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
-  });
-  test('appropriate properties are set with valid values -- with refresh', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    const requiredKeys = ['onEnd', 'refresh', 'initialMs', 'startTimestamp', 'timer'];
-    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
-  });
-  test('required keys are enforced', () => {
-    try {
-      new InteractionTimer({}, 100);
-    } catch (e) {
-      expect(e).toEqual(new Error('onEnd handler is required'));
-    }
-    try {
-      new InteractionTimer({
-        onEnd: jest.fn()
-      });
-    } catch (e) {
-      expect(e).toEqual(new Error('ms duration is required'));
-    }
-  });
-  test('refresh type timers set event listeners', () => {
-    // eslint-disable-next-line
-    let ee = {
-      on: jest.fn().mockImplementation((evt, cb) => {
-        cb([{
-          type: 'click'
-        }]);
-      })
-    };
-    let it = new InteractionTimer({
-      onEnd: jest.fn(),
-      onRefresh: jest.fn(),
-      ee
-    }, 100);
-    // scroll, keypress, click
-    expect(ee.on).toHaveBeenCalledTimes(1);
-    expect(it.onRefresh).toHaveBeenCalledTimes(1);
-
-    // eslint-disable-next-line
-    ee = {
-      on: jest.fn().mockImplementation((evt, cb) => {
-        cb([{
-          type: 'scroll'
-        }]);
-      })
-    };
-    it = new InteractionTimer({
-      onEnd: jest.fn(),
-      onRefresh: jest.fn(),
-      ee
-    }, 100);
-    // scroll, keypress, click
-    expect(ee.on).toHaveBeenCalledTimes(1);
-    expect(it.onRefresh).toHaveBeenCalledTimes(1);
-
-    // eslint-disable-next-line
-    ee = {
-      on: jest.fn().mockImplementation((evt, cb) => {
-        cb([{
-          type: 'keydown'
-        }]);
-      })
-    };
-    it = new InteractionTimer({
-      onEnd: jest.fn(),
-      onRefresh: jest.fn(),
-      ee
-    }, 100);
-    // scroll, keypress, click
-    expect(ee.on).toHaveBeenCalledTimes(1);
-    expect(it.onRefresh).toHaveBeenCalledTimes(1);
-    const aelSpy = jest.spyOn(document, 'addEventListener');
-    // eslint-disable-next-line
-    ee = {
-      on: jest.fn().mockImplementation((evt, cb) => {
-        cb([{
-          type: 'keydown'
-        }]);
-      })
-    };
-    it = new InteractionTimer({
-      onEnd: jest.fn(),
-      onRefresh: jest.fn(),
-      ee
-    }, 100);
-    // visibility change
-    expect(aelSpy).toHaveBeenCalledTimes(1);
-  });
-});
-describe('create()', () => {
-  test('Create sets a timeout that can execute a cb', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.timer).toBeTruthy();
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    jest.runOnlyPendingTimers();
-    expect(timer.onEnd).toHaveBeenCalledTimes(1);
-  });
-  test('Create can fallback to use defaults', () => {
-    let called = 0;
-    const timer1 = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    timer1.create();
-    const timer2 = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    timer2.create(timer2.onEnd);
-    const timer3 = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    timer3.create(undefined, 100);
-    jest.runAllTimers(200);
-    expect(timer1.onEnd).toHaveBeenCalledTimes(1);
-    expect(timer2.onEnd).toHaveBeenCalledTimes(1);
-    expect(timer3.onEnd).toHaveBeenCalledTimes(1);
-  });
-});
-describe('refresh()', () => {
-  test('refresh prevents the callback from firing', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn(),
-      onRefresh: jest.fn()
-    }, 100);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    jest.advanceTimersByTime(75);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    timer.refresh();
-    jest.advanceTimersByTime(75);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    jest.advanceTimersByTime(100);
-    expect(timer.onEnd).toHaveBeenCalledTimes(1);
-  });
-  test('refresh executes a callback for consumers', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn(),
-      onRefresh: jest.fn()
-    }, 100);
-    timer.refresh();
-    expect(timer.onRefresh).toHaveBeenCalledTimes(1);
-  });
-});
-describe('pause()', () => {
-  test('pause prevents the callback from firing', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    timer.pause();
-    jest.advanceTimersByTime(150);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-  });
-  test('pause sets remainingMs timestamp', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.remainingMs).toEqual(undefined);
-    timer.pause();
-    expect(timer.remainingMs).toEqual(timer.initialMs - (now - timer.startTimestamp));
-  });
-});
-describe('clear()', () => {
-  test('clear prevents the callback from firing and deletes the pointer', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    timer.clear();
-    jest.advanceTimersByTime(150);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    expect(timer.timer).toEqual(null);
-  });
-});
-describe('end()', () => {
-  test('end clears the callback and calls the onEnd callback', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    timer.end();
-    expect(timer.onEnd).toHaveBeenCalledTimes(1);
-    expect(timer.timer).toEqual(null);
-  });
-});
-describe('isValid', () => {
-  test('isValid validates timeStamps', () => {
-    const timer = new InteractionTimer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.isValid()).toEqual(true);
-    timer.startTimestamp -= 100;
-    expect(timer.isValid()).toEqual(false);
-  });
-});

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

@@ -1,103 +0,0 @@
-import { Timer } from './timer';
-jest.useFakeTimers();
-let now;
-beforeEach(() => {
-  now = Date.now();
-  jest.setSystemTime(now);
-});
-afterEach(() => {
-  jest.clearAllMocks();
-});
-describe('constructor', () => {
-  test('appropriate properties are set with valid values -- no refresh', () => {
-    const timer = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
-    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
-  });
-  test('appropriate properties are set with valid values -- with refresh', () => {
-    const timer = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer'];
-    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy();
-  });
-  test('required keys are enforced', () => {
-    try {
-      new Timer({}, 100);
-    } catch (e) {
-      expect(e).toEqual(new Error('onEnd handler is required'));
-    }
-    try {
-      new Timer({
-        onEnd: jest.fn()
-      });
-    } catch (e) {
-      expect(e).toEqual(new Error('ms duration is required'));
-    }
-  });
-});
-describe('create()', () => {
-  test('Create sets a timeout that can execute a cb', () => {
-    const timer = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.timer).toBeTruthy();
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    jest.runOnlyPendingTimers();
-    expect(timer.onEnd).toHaveBeenCalledTimes(1);
-  });
-  test('Create can fallback to use defaults', () => {
-    let called = 0;
-    const timer1 = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    timer1.create();
-    const timer2 = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    timer2.create(timer2.onEnd);
-    const timer3 = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    timer3.create(undefined, 100);
-    jest.runAllTimers(200);
-    expect(timer1.onEnd).toHaveBeenCalledTimes(1);
-    expect(timer2.onEnd).toHaveBeenCalledTimes(1);
-    expect(timer3.onEnd).toHaveBeenCalledTimes(1);
-  });
-});
-describe('clear()', () => {
-  test('clear prevents the callback from firing and deletes the pointer', () => {
-    const timer = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    timer.clear();
-    jest.advanceTimersByTime(150);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    expect(timer.timer).toEqual(null);
-  });
-});
-describe('end()', () => {
-  test('end clears the callback and calls the onEnd callback', () => {
-    const timer = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.onEnd).toHaveBeenCalledTimes(0);
-    timer.end();
-    expect(timer.onEnd).toHaveBeenCalledTimes(1);
-    expect(timer.timer).toEqual(null);
-  });
-});
-describe('isValid', () => {
-  test('isValid validates timeStamps', () => {
-    const timer = new Timer({
-      onEnd: jest.fn()
-    }, 100);
-    expect(timer.isValid()).toEqual(true);
-    timer.startTimestamp -= 100;
-    expect(timer.isValid()).toEqual(false);
-  });
-});

package/dist/esm/common/timing/nav-timing.test.js

@@ -1,190 +0,0 @@
-import { addPT, addPN, navTimingValues } from './nav-timing';
-const offset = 123;
-const testValues = {
-  unloadEventStart: 1,
-  redirectStart: 2,
-  unloadEventEnd: 3,
-  redirectEnd: 4,
-  fetchStart: 5,
-  domainLookupStart: 6,
-  domainLookupEnd: 7,
-  connectStart: 8,
-  secureConnectionStart: 9,
-  connectEnd: 10,
-  requestStart: 11,
-  responseStart: 12,
-  responseEnd: 13,
-  domLoading: 14,
-  domInteractive: 15,
-  domContentLoadedEventStart: 16,
-  domContentLoadedEventEnd: 17,
-  domComplete: 18,
-  loadEventStart: 19,
-  loadEventEnd: 20,
-  type: 'reload',
-  redirectCount: 22
-};
-const legacyTestValues = {
-  unloadEventStart: offset + 1,
-  redirectStart: offset + 2,
-  unloadEventEnd: offset + 3,
-  redirectEnd: offset + 4,
-  fetchStart: offset + 5,
-  domainLookupStart: offset + 6,
-  domainLookupEnd: offset + 7,
-  connectStart: offset + 8,
-  secureConnectionStart: offset + 9,
-  connectEnd: offset + 10,
-  requestStart: offset + 11,
-  responseStart: offset + 12,
-  responseEnd: offset + 13,
-  domLoading: offset + 14,
-  domInteractive: offset + 15,
-  domContentLoadedEventStart: offset + 16,
-  domContentLoadedEventEnd: offset + 17,
-  domComplete: offset + 18,
-  loadEventStart: offset + 19,
-  loadEventEnd: offset + 20,
-  type: 'reload',
-  redirectCount: offset + 22
-};
-const expectedPT = {
-  of: offset,
-  n: 0,
-  u: 1,
-  r: 2,
-  ue: 3,
-  re: 4,
-  f: 5,
-  dn: 6,
-  dne: 7,
-  c: 8,
-  s: 9,
-  ce: 10,
-  rq: 11,
-  rp: 12,
-  rpe: 13,
-  dl: 14,
-  di: 15,
-  ds: 16,
-  de: 17,
-  dc: 18,
-  l: 19,
-  le: 20
-};
-const expectedPN = {
-  ty: 1,
-  rc: 22
-};
-describe('addPT()', () => {
-  test('an output object is populated with valid values', () => {
-    const output = addPT(offset, testValues, {});
-    expect(output).toEqual(expectedPT);
-  });
-  test('an object with invalid values is handled', () => {
-    const output = addPT(offset, {
-      ...testValues,
-      invalidValue: 'test'
-    }, {});
-    expect(output).toEqual(expectedPT);
-    const output2 = addPT(offset, {
-      ...testValues,
-      loadEventEnd: -1
-    }, {});
-    let expected = {
-      ...expectedPT
-    };
-    delete expected.le;
-    expect(output2).toEqual(expected);
-    const output3 = addPT(offset, {
-      ...testValues,
-      loadEventEnd: 'test'
-    }, {});
-    expected = {
-      ...expectedPT
-    };
-    delete expected.le;
-    expect(output3).toEqual(expected);
-    const output4 = addPT(offset, {
-      ...testValues,
-      loadEventEnd: null
-    }, {});
-    expected = {
-      ...expectedPT
-    };
-    delete expected.le;
-    expect(output4).toEqual(expected);
-    const legacyoutput = addPT(offset, {
-      ...legacyTestValues,
-      invalidValue: 'test'
-    }, {}, true);
-    expect(legacyoutput).toEqual(expectedPT);
-    const legacyoutput2 = addPT(offset, {
-      ...legacyTestValues,
-      loadEventEnd: -1
-    }, {}, true);
-    let legacyexpected = {
-      ...expectedPT
-    };
-    delete legacyexpected.le;
-    expect(legacyoutput2).toEqual(expected);
-    const legacyoutput3 = addPT(offset, {
-      ...legacyTestValues,
-      loadEventEnd: 'test'
-    }, {}, true);
-    legacyexpected = {
-      ...expectedPT
-    };
-    delete legacyexpected.le;
-    expect(legacyoutput3).toEqual(legacyexpected);
-    const legacyoutput4 = addPT(offset, {
-      ...legacyTestValues,
-      loadEventEnd: null
-    }, {}, true);
-    legacyexpected = {
-      ...expectedPT
-    };
-    delete legacyexpected.le;
-    expect(legacyoutput4).toEqual(legacyexpected);
-  });
-  test('rounds values to integers', () => {
-    const output = addPT(offset, {
-      unloadEventStart: 3.14159
-    }, {});
-    expect(output.u).toEqual(3);
-    const legacyoutput = addPT(0, {
-      unloadEventStart: 3.14159
-    }, {}, true);
-    expect(legacyoutput.u).toEqual(3);
-  });
-  test('adds entries to navTimingValues', () => {
-    const beforeLength = navTimingValues.length;
-    addPT(offset, {
-      testValues
-    }, {});
-    const afterLength = navTimingValues.length;
-    expect(afterLength - beforeLength).toEqual(21); // 20 + value of n
-
-    const legacybeforeLength = navTimingValues.length;
-    addPT(offset, {
-      legacyTestValues
-    }, {}, true);
-    const legacyafterLength = navTimingValues.length;
-    expect(legacyafterLength - legacybeforeLength).toEqual(21); // 20 + value of n
-  });
-});
-
-describe('addPN()', () => {
-  test('an output object is populated with valid values', () => {
-    const output = addPN(testValues, {});
-    expect(output).toEqual(expectedPN);
-  });
-  test('adds entries to navTimingValues', () => {
-    const beforeLength = navTimingValues.length;
-    addPN(offset, {
-      testValues
-    }, {});
-    const afterLength = navTimingValues.length;
-    expect(afterLength - beforeLength).toEqual(2);
-  });
-});

package/dist/esm/common/url/canonicalize-url.test.js

@@ -1,34 +0,0 @@
-import { faker } from '@faker-js/faker';
-import * as globalScopeModule from '../util/global-scope';
-import * as cleanUrlModule from './clean-url';
-import { canonicalizeUrl } from './canonicalize-url';
-jest.mock('../util/global-scope');
-jest.mock('./clean-url');
-beforeEach(() => {
-  jest.spyOn(cleanUrlModule, 'cleanURL').mockImplementation(input => input);
-  jest.replaceProperty(globalScopeModule, 'initialLocation', faker.internet.url());
-});
-afterEach(() => {
-  jest.resetAllMocks();
-});
-test.each([null, undefined, 34])('returns empty string when url argument is %s', async url => {
-  expect(canonicalizeUrl(url)).toEqual('');
-});
-test('uses cleanURL to clean the input and initial location URLs', () => {
-  const url = faker.internet.url();
-  canonicalizeUrl(url);
-  expect(cleanUrlModule.cleanURL).toHaveBeenCalledWith(globalScopeModule.initialLocation);
-  expect(cleanUrlModule.cleanURL).toHaveBeenCalledWith(url);
-  expect(cleanUrlModule.cleanURL).toHaveBeenCalledTimes(2);
-});
-test('returns <inline> when input and initial page urls are the same', async () => {
-  expect(canonicalizeUrl(globalScopeModule.initialLocation)).toEqual('<inline>');
-});
-test('returns input url when it does not match initial page url', async () => {
-  const url = faker.internet.url();
-  expect(canonicalizeUrl(url)).toEqual(url);
-});
-test('does not identify sub-paths of the loader origin as <inline>', async () => {
-  const url = globalScopeModule.initialLocation + '/path/to/script.js';
-  expect(canonicalizeUrl(url)).not.toEqual('<inline>');
-});

package/dist/esm/common/url/clean-url.test.js

@@ -1,7 +0,0 @@
-import { cleanURL } from './clean-url';
-test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path']])('cleanURL should remove hash', (input, expected) => {
-  expect(cleanURL(input)).toEqual(expected);
-});
-test.each([['http://domain.com/path?query=5', 'http://domain.com/path'], ['http://domain.com/path#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path#fragment'], ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path#fragment#dumb'], ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path#fragment/silly/dumber#dumbest']])('cleanURL should retain hash if second argument is true', (input, expected) => {
-  expect(cleanURL(input, true)).toEqual(expected);
-});

package/dist/esm/common/url/encode.component-test.js

@@ -1,70 +0,0 @@
-import * as encode from './encode';
-describe('query string encoding', () => {
-  test('escapes string components except safe characters', () => {
-    const input = 'Asdf:, :, /@$;';
-    const expected = 'Asdf:,%20:,%20/@$;';
-    expect(encode.qs(input)).toEqual(expected);
-  });
-  test('null and undefined value returns \'null\'', () => {
-    expect(encode.qs(null)).toEqual('null');
-    expect(encode.qs(undefined)).toEqual('null');
-  });
-});
-describe('fromArray encoding', () => {
-  test('cuts cleanly at end of byte', () => {
-    const input = ['a', 'b', 'c'];
-    const expected = 'ab';
-    expect(encode.fromArray(input, 2)).toEqual(expected);
-  });
-  test('fall back to largest whole chunk', () => {
-    const input = ['aa', 'bb', 'cc'];
-    const expected = 'aabb';
-    expect(encode.fromArray(input, 5)).toEqual(expected);
-  });
-});
-describe('object encoding', () => {
-  test('cuts cleanly at end of byte', () => {
-    const input = {
-      foo: [1, 2, 3]
-    };
-    const expected = '&foo=%5B1,2%5D';
-    expect(encode.obj(input, 12)).toEqual(expected);
-  });
-  test('fall back to largest whole chunk', () => {
-    const input = {
-      bar: ['a', 'b', 'c']
-    };
-    const expected = '&bar=%5B%22a%22,%22b%22%5D';
-    expect(encode.obj(input, 30)).toEqual(expected);
-  });
-  test('handles circular objects', () => {
-    const circular = {};
-    circular.circular = circular;
-    const input = {
-      bar: ['a', circular, 'c']
-    };
-    const expected = '&bar=%5B%22a%22,%7B%7D,%22c%22%5D';
-    expect(encode.obj(input, 1000)).toEqual(expected);
-  });
-  test('handles circular arrays', () => {
-    const circular = [];
-    circular.push(circular);
-    const input = {
-      bar: ['a', circular, 'c']
-    };
-    const expected = '&bar=%5B%22a%22,%5Bnull%5D,%22c%22%5D';
-    expect(encode.obj(input, 1000)).toEqual(expected);
-  });
-});
-describe('encode key value pairs as query params', () => {
-  test('ignores input when value is null or undefined', () => {
-    expect(encode.param('foo', null)).toEqual('');
-    expect(encode.param('foo', undefined)).toEqual('');
-  });
-  test('encodes key value pair correctly', () => {
-    expect(encode.param('foo', 'bar')).toEqual('&foo=bar');
-  });
-  test('ignores input when value is not a string', () => {
-    expect(encode.param('foo', {})).toEqual('');
-  });
-});

package/dist/esm/common/url/location.test.js

@@ -1,11 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { getLocation } from './location';
-test('should always return a string', () => {
-  jest.spyOn(window, 'location', 'get').mockReturnValue({});
-  expect(typeof getLocation()).toEqual('string');
-});
-test('should return window location', () => {
-  const expected = faker.internet.url();
-  jest.spyOn(window, 'location', 'get').mockReturnValue(expected);
-  expect(getLocation()).toEqual(expected);
-});