@newrelic/browser-agent 1.235.0 → 1.237.0

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);
-});

package/dist/esm/common/session/session-entity.component-test.js

@@ -1,495 +0,0 @@
-import { PREFIX } from './constants';
-import { SessionEntity } from './session-entity';
-const agentIdentifier = 'test_agent_identifier';
-const key = 'test_key';
-const value = 'test_value';
-class LocalMemory {
-  constructor() {
-    let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.state = initialState;
-  }
-  get(key) {
-    try {
-      return this.state[key];
-    } catch (err) {
-      return '';
-    }
-  }
-  set(key, value) {
-    try {
-      if (value === undefined || value === null) return this.remove(key);
-      this.state[key] = value;
-    } catch (err) {
-      return;
-    }
-  }
-  remove(key) {
-    try {
-      delete this.state[key];
-    } catch (err) {
-      return;
-    }
-  }
-}
-jest.mock('../timer/timer');
-jest.mock('../timer/interaction-timer');
-jest.useFakeTimers();
-const mockBrowserScope = jest.fn().mockImplementation(() => true);
-jest.mock('../util/global-scope', () => ({
-  __esModule: true,
-  get isBrowserScope() {
-    return mockBrowserScope();
-  },
-  get globalScope() {
-    return global.window;
-  }
-}));
-let storage;
-beforeEach(() => {
-  jest.restoreAllMocks();
-  mockBrowserScope.mockReturnValue(true);
-  storage = new LocalMemory();
-});
-describe('constructor', () => {
-  test('must use required fields', () => {
-    try {
-      expect(new SessionEntity({})).toThrow(new Error('Missing Required Fields'));
-    } catch (err) {}
-  });
-  test('top-level properties are set and exposed', () => {
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    expect(session).toMatchObject({
-      agentIdentifier: expect.any(String),
-      key: expect.any(String),
-      expiresMs: expect.any(Number),
-      expiresTimer: expect.any(Object),
-      inactiveMs: expect.any(Number),
-      inactiveTimer: expect.any(Object),
-      isNew: expect.any(Boolean),
-      storage: expect.any(Object),
-      state: expect.objectContaining({
-        value: expect.any(String),
-        expiresAt: expect.any(Number),
-        inactiveAt: expect.any(Number),
-        sessionReplay: expect.any(Number),
-        sessionTraceMode: expect.any(Number)
-      })
-    });
-  });
-  test('can use sane defaults', () => {
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }));
-  });
-  test('expiresAt is the correct future timestamp - new session', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      expiresMs: 100
-    });
-    expect(session.state.expiresAt).toEqual(now + 100);
-  });
-  test('expiresAt is the correct future timestamp - existing session', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const existingData = new LocalMemory({
-      ["".concat(PREFIX, "_").concat(key)]: {
-        value,
-        expiresAt: now + 5000,
-        inactiveAt: Infinity,
-        updatedAt: now,
-        sessionReplay: 0,
-        sessionTraceMode: 0,
-        custom: {}
-      }
-    });
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      expiresMs: 100,
-      storage: existingData
-    });
-    expect(session.state.expiresAt).toEqual(now + 5000);
-  });
-  test('expiresAt never expires if 0', () => {
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      expiresMs: 0
-    });
-    expect(session.state.expiresAt).toEqual(Infinity);
-  });
-  test('inactiveAt is the correct future timestamp - new session', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      inactiveMs: 100
-    });
-    expect(session.state.inactiveAt).toEqual(now + 100);
-  });
-  test('inactiveAt is the correct future timestamp - existing session', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const existingData = new LocalMemory({
-      ["".concat(PREFIX, "_").concat(key)]: {
-        value,
-        inactiveAt: now + 5000,
-        expiresAt: Infinity,
-        updatedAt: now,
-        sessionReplay: 0,
-        sessionTraceMode: 0,
-        custom: {}
-      }
-    });
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      inactiveMs: 100,
-      storage: existingData
-    });
-    expect(session.state.inactiveAt).toEqual(now + 5000);
-  });
-  test('inactiveAt never expires if 0', () => {
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      inactiveMs: 0
-    });
-    expect(session.state.inactiveAt).toEqual(Infinity);
-  });
-  test('should handle isNew', () => {
-    const newSession = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      expiresMs: 10
-    });
-    expect(newSession.isNew).toBeTruthy();
-    const newStorage = new LocalMemory({
-      ["".concat(PREFIX, "_").concat(key)]: {
-        value,
-        expiresAt: Infinity,
-        inactiveAt: Infinity,
-        updatedAt: Date.now(),
-        sessionReplay: 0,
-        sessionTraceMode: 0,
-        custom: {}
-      }
-    });
-    const existingSession = new SessionEntity({
-      agentIdentifier,
-      key,
-      expiresMs: 10,
-      storage: newStorage
-    });
-    expect(existingSession.isNew).toBeFalsy();
-  });
-  test('invalid stored values sets new defaults', () => {
-    // missing required fields
-    const storage = new LocalMemory({
-      ["".concat(PREFIX, "_").concat(key)]: {
-        invalid_fields: true
-      }
-    });
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }));
-  });
-  test('expired expiresAt value in storage sets new defaults', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const storage = new LocalMemory({
-      ["".concat(PREFIX, "_").concat(key)]: {
-        value,
-        expiresAt: now - 100,
-        inactiveAt: Infinity
-      }
-    });
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }));
-  });
-  test('expired inactiveAt value in storage sets new defaults', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const storage = new LocalMemory({
-      ["".concat(PREFIX, "_").concat(key)]: {
-        value,
-        inactiveAt: now - 100,
-        expiresAt: Infinity
-      }
-    });
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    expect(session.state).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      updatedAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }));
-  });
-});
-describe('reset()', () => {
-  test('should create new default values when resetting', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      expiresMs: 10
-    });
-    const sessionVal = session.value;
-    expect(session.state.value).toBeTruthy();
-    session.reset();
-    expect(session.state.value).toBeTruthy();
-    expect(session.state.value).not.toEqual(sessionVal);
-  });
-  test('custom data should be wiped on reset', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      expiresMs: 10
-    });
-    session.syncCustomAttribute('test', 123);
-    expect(session.state.custom.test).toEqual(123);
-    expect(session.read().custom.test).toEqual(123);
-
-    // simulate a timer expiring
-    session.reset();
-    expect(session.state.custom?.test).toEqual(undefined);
-    expect(session.read()?.custom?.test).toEqual(undefined);
-  });
-});
-describe('read()', () => {
-  test('"new" sessions get data from read()', () => {
-    const newSession = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      expiresMs: 10
-    });
-    expect(newSession.isNew).toBeTruthy();
-    expect(newSession.read()).toEqual(expect.objectContaining({
-      value: expect.any(String),
-      expiresAt: expect.any(Number),
-      inactiveAt: expect.any(Number),
-      sessionReplay: expect.any(Number),
-      sessionTraceMode: expect.any(Number)
-    }));
-  });
-  test('"pre-existing" sessions get data from read()', () => {
-    const storage = new LocalMemory({
-      ["".concat(PREFIX, "_").concat(key)]: {
-        value,
-        expiresAt: Infinity,
-        inactiveAt: Infinity,
-        updatedAt: Date.now(),
-        sessionReplay: 0,
-        sessionTraceMode: 0,
-        custom: {}
-      }
-    });
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    expect(session.isNew).toBeFalsy();
-    expect(session.read()).toEqual(expect.objectContaining({
-      value,
-      expiresAt: Infinity,
-      inactiveAt: Infinity
-    }));
-  });
-});
-describe('write()', () => {
-  test('write() sets data to top-level wrapper', () => {
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    expect(session.state.value).not.toEqual(value);
-    expect(session.state.expiresAt).not.toEqual(Infinity);
-    expect(session.state.inactiveAt).not.toEqual(Infinity);
-    session.write({
-      ...session.state,
-      value,
-      expiresAt: Infinity,
-      inactiveAt: Infinity
-    });
-    expect(session.state.value).toEqual(value);
-    expect(session.state.expiresAt).toEqual(Infinity);
-    expect(session.state.inactiveAt).toEqual(Infinity);
-  });
-  test('write() sets data that read() can access', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    session.write({
-      ...session.state,
-      value,
-      expiresAt: now + 100,
-      inactiveAt: now + 100
-    });
-    const read = session.read();
-    expect(read.value).toEqual(value);
-    expect(read.expiresAt).toEqual(now + 100);
-    expect(read.inactiveAt).toEqual(now + 100);
-  });
-  test('write() does not run with invalid data', () => {
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    let out = session.write();
-    expect(out).toEqual(undefined);
-    out = session.write('string');
-    expect(out).toEqual(undefined);
-    out = session.write(123);
-    expect(out).toEqual(undefined);
-    out = session.write(true);
-    expect(out).toEqual(undefined);
-    out = session.write(false);
-    expect(out).toEqual(undefined);
-  });
-});
-describe('refresh()', () => {
-  test('refresh sets inactiveAt to future time', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      inactiveMs: 100
-    });
-    expect(session.state.inactiveAt).toEqual(now + 100);
-    jest.setSystemTime(now + 1000);
-    session.refresh();
-    expect(session.state.inactiveAt).toEqual(now + 100 + 1000);
-  });
-  test('refresh resets the entity if expiresTimer is invalid', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      value
-    });
-    expect(session.state.value).toEqual(value);
-    session.write({
-      ...session.state,
-      expiresAt: now - 1
-    });
-    session.refresh();
-    expect(session.state.value).not.toEqual(value);
-  });
-  test('refresh resets the entity if inactiveTimer is invalid', () => {
-    const now = Date.now();
-    jest.setSystemTime(now);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage,
-      value
-    });
-    expect(session.state.value).toEqual(value);
-    session.write({
-      ...session.state,
-      inactiveAt: now - 1
-    });
-    session.refresh();
-    expect(session.state.value).not.toEqual(value);
-  });
-});
-describe('syncCustomAttribute()', () => {
-  test('Custom data can be managed by session entity', () => {
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-
-    // if custom has never been set, and a "delete" action is triggered, do nothing
-    session.syncCustomAttribute('test', null);
-    expect(session?.state?.custom?.test).toEqual(undefined);
-    session.syncCustomAttribute('test', 1);
-    expect(session?.state?.custom?.test).toEqual(1);
-    session.syncCustomAttribute('test', 'string');
-    expect(session?.state?.custom?.test).toEqual('string');
-    session.syncCustomAttribute('test', false);
-    expect(session?.state?.custom?.test).toEqual(false);
-
-    // null specifically deletes the object completely
-    session.syncCustomAttribute('test', null);
-    expect(session?.state?.custom?.test).toEqual(undefined);
-  });
-  test('Only runs in browser scope', () => {
-    mockBrowserScope.mockReturnValue(false);
-    const session = new SessionEntity({
-      agentIdentifier,
-      key,
-      storage
-    });
-    session.syncCustomAttribute('test', 1);
-    expect(session.read().custom?.test).toEqual(undefined);
-  });
-});

package/dist/esm/common/storage/local-storage.test.js

@@ -1,12 +0,0 @@
-import { LocalStorage } from './local-storage';
-test('Local-memory', () => {
-  const LS = new LocalStorage();
-  LS.set('test', 1);
-  expect(LS.get('test')).toEqual('1');
-  LS.set('test');
-  expect(LS.get('test')).toEqual(undefined);
-  LS.set('test', 2);
-  expect(LS.get('test')).toEqual('2');
-  LS.remove('test');
-  expect(LS.get('test')).toEqual(undefined);
-});