@newrelic/browser-agent 0.1.230 → 1.232.0

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

@@ -0,0 +1,214 @@
+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.js

@@ -0,0 +1,25 @@
+export class Timer {
+  constructor(opts, ms) {
+    if (!opts.onEnd) throw new Error('onEnd handler is required');
+    if (!ms) throw new Error('ms duration is required');
+    this.onEnd = opts.onEnd;
+    this.initialMs = ms;
+    this.startTimestamp = Date.now();
+    this.timer = this.create(this.onEnd, ms);
+  }
+  create(cb, ms) {
+    if (this.timer) this.clear();
+    return setTimeout(() => cb ? cb() : this.onEnd(), ms || this.initialMs);
+  }
+  clear() {
+    clearTimeout(this.timer);
+    this.timer = null;
+  }
+  end() {
+    this.clear();
+    this.onEnd();
+  }
+  isValid() {
+    return this.initialMs - (Date.now() - this.startTimestamp) > 0;
+  }
+}

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

@@ -0,0 +1,103 @@
+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.js

@@ -25,43 +25,65 @@ var RESPONSE = 'response';
 var LOAD_EVENT = 'loadEvent';
 var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent';
 export var navTimingValues = [];
-export function addPT(offset, pt, v) {
+function getPntType(type) {
+  if (typeof type == 'number') return type;
+  const types = {
+    navigate: undefined,
+    reload: 1,
+    back_forward: 2,
+    prerender: 3
+  };
+  return types[type];
+}
+export function addPT(offset, pt) {
+  let v = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let isL1Api = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!pt) return;
   v.of = offset;
-  addRel(offset, offset, v, 'n');
-  addRel(pt[UNLOAD_EVENT + START], offset, v, 'u');
-  addRel(pt[REDIRECT + START], offset, v, 'r');
-  addRel(pt[UNLOAD_EVENT + END], offset, v, 'ue');
-  addRel(pt[REDIRECT + END], offset, v, 're');
-  addRel(pt['fetch' + START], offset, v, 'f');
-  addRel(pt[DOMAIN_LOOKUP + START], offset, v, 'dn');
-  addRel(pt[DOMAIN_LOOKUP + END], offset, v, 'dne');
-  addRel(pt['c' + ONNECT + START], offset, v, 'c');
-  addRel(pt['secureC' + ONNECT + 'ion' + START], offset, v, 's');
-  addRel(pt['c' + ONNECT + END], offset, v, 'ce');
-  addRel(pt[REQUEST + START], offset, v, 'rq');
-  addRel(pt[RESPONSE + START], offset, v, 'rp');
-  addRel(pt[RESPONSE + END], offset, v, 'rpe');
-  addRel(pt.domLoading, offset, v, 'dl');
-  addRel(pt.domInteractive, offset, v, 'di');
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + START], offset, v, 'ds');
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + END], offset, v, 'de');
-  addRel(pt.domComplete, offset, v, 'dc');
-  addRel(pt[LOAD_EVENT + START], offset, v, 'l');
-  addRel(pt[LOAD_EVENT + END], offset, v, 'le');
+  handleValue(v.of, v, 'n', true);
+  handleValue(pt[UNLOAD_EVENT + START], v, 'u', isL1Api);
+  handleValue(pt[REDIRECT + START], v, 'r', isL1Api);
+  handleValue(pt[UNLOAD_EVENT + END], v, 'ue', isL1Api);
+  handleValue(pt[REDIRECT + END], v, 're', isL1Api);
+  handleValue(pt['fetch' + START], v, 'f', isL1Api);
+  handleValue(pt[DOMAIN_LOOKUP + START], v, 'dn', isL1Api);
+  handleValue(pt[DOMAIN_LOOKUP + END], v, 'dne', isL1Api);
+  handleValue(pt['c' + ONNECT + START], v, 'c', isL1Api);
+  handleValue(pt['secureC' + ONNECT + 'ion' + START], v, 's', isL1Api);
+  handleValue(pt['c' + ONNECT + END], v, 'ce', isL1Api);
+  handleValue(pt[REQUEST + START], v, 'rq', isL1Api);
+  handleValue(pt[RESPONSE + START], v, 'rp', isL1Api);
+  handleValue(pt[RESPONSE + END], v, 'rpe', isL1Api);
+  handleValue(pt.domLoading, v, 'dl', isL1Api);
+  handleValue(pt.domInteractive, v, 'di', isL1Api);
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + START], v, 'ds', isL1Api);
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + END], v, 'de', isL1Api);
+  handleValue(pt.domComplete, v, 'dc', isL1Api);
+  handleValue(pt[LOAD_EVENT + START], v, 'l', isL1Api);
+  handleValue(pt[LOAD_EVENT + END], v, 'le', isL1Api);
   return v;
 }
 
 // Add Performance Navigation values to the given object
 export function addPN(pn, v) {
-  addRel(pn.type, 0, v, 'ty');
-  addRel(pn.redirectCount, 0, v, 'rc');
+  handleValue(getPntType(pn.type), v, 'ty');
+  handleValue(pn.redirectCount, v, 'rc');
   return v;
 }
-export function addRel(value, offset, obj, prop) {
-  var relativeValue;
+function handleValue(value, obj, prop, isOldApi) {
+  /*
+  For L2 Timing API, the value will already be a relative-to-previous-document DOMHighResTimeStamp.
+  For L1 (deprecated) Timing, the value is an UNIX epoch timestamp, which we will convert to a relative time using our offset.
+  PNT.type is reported as undefined, 1, 2, etc -- note that zero-value properties will be recorded as 'undefined', however DEM interprets undefined "types" as "navigate"
+  */
   if (typeof value === 'number' && value > 0) {
-    relativeValue = Math.max(Math.round(value - offset), 0);
-    obj[prop] = relativeValue;
+    // note that zero-value properties will be recorded as 'undefined'
+    if (isOldApi) {
+      const offset = obj?.of > 0 ? obj.of : 0; // expect an epoch timestamp, if called by addPT
+      value = Math.max(value - offset, 0);
+    }
+    value = Math.round(value);
+    obj[prop] = value;
   }
-  navTimingValues.push(relativeValue);
+  navTimingValues.push(value);
 }

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

@@ -0,0 +1,190 @@
+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/unload/eol.js

@@ -4,7 +4,7 @@
  */
 import { ffVersion } from '../browser-version/firefox-version';
 import { windowAddEventListener } from '../event-listener/event-listener-opts';
-import { single } from '../util/single';
+import { single } from '../util/invoke';
 import { globalScope, isWorkerScope, isBrowserScope } from '../util/global-scope';
 import { subscribeToVisibilityChange } from '../window/page-visibility';
 if (isWorkerScope) {

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

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