@newrelic/browser-agent 1.235.0 → 1.237.0

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

@@ -1,107 +0,0 @@
-afterEach(() => {
-  jest.resetModules();
-  jest.clearAllMocks();
-});
-const urlTests = [{
-  input: 'http://example.com/path/name?qs=5&a=b',
-  expected: {
-    hostname: 'example.com',
-    pathname: '/path/name',
-    protocol: 'http',
-    port: '80',
-    sameOrigin: false
-  }
-}, {
-  input: 'http://foo:bar@example.com:8080/path/@name?qs=5&a=b',
-  expected: {
-    hostname: 'example.com',
-    pathname: '/path/@name',
-    protocol: 'http',
-    port: '8080',
-    sameOrigin: false
-  }
-}, {
-  input: 'https://foo:bar@example.com/path/name?qs=5&a=b',
-  expected: {
-    hostname: 'example.com',
-    pathname: '/path/name',
-    protocol: 'https',
-    port: '443',
-    sameOrigin: false
-  }
-}, {
-  input: '/path/name?qs=5&a=b',
-  expected: {
-    hostname: location.hostname,
-    pathname: '/path/name',
-    protocol: location.protocol.split(':')[0],
-    port: '80',
-    sameOrigin: true
-  }
-}, {
-  input: location.protocol + '//' + location.hostname + ':' + location.port + '/path/name?qs=5&a=b',
-  expected: {
-    hostname: location.hostname,
-    pathname: '/path/name',
-    protocol: location.protocol.split(':')[0],
-    port: '80',
-    sameOrigin: true
-  }
-}, {
-  input: 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==',
-  expected: {
-    protocol: 'data'
-  }
-}];
-test.each(urlTests)('verify url parsing inside browser scope', async _ref => {
-  let {
-    input,
-    expected
-  } = _ref;
-  jest.doMock('../util/global-scope', () => ({
-    __esModule: true,
-    isBrowserScope: true,
-    globalScope: global
-  }));
-  const {
-    parseUrl
-  } = await import('./parse-url');
-  expect(parseUrl(input)).toEqual(expected);
-});
-test.each(urlTests)('verify url parsing outside browser scope', async _ref2 => {
-  let {
-    input,
-    expected
-  } = _ref2;
-  jest.doMock('../util/global-scope', () => ({
-    __esModule: true,
-    isBrowserScope: false,
-    globalScope: global
-  }));
-  const {
-    parseUrl
-  } = await import('./parse-url');
-  expect(parseUrl(input)).toEqual(expected);
-});
-test('should cache parsed urls', async () => {
-  jest.doMock('../util/global-scope', () => ({
-    __esModule: true,
-    isBrowserScope: true,
-    globalScope: global
-  }));
-  const input = 'http://example.com/';
-  const expected = {
-    hostname: 'example.com',
-    pathname: '/',
-    protocol: 'http',
-    port: '80',
-    sameOrigin: false
-  };
-  jest.spyOn(document, 'createElement');
-  const {
-    parseUrl
-  } = await import('./parse-url');
-  parseUrl(input);
-  expect(parseUrl(input)).toEqual(expected);
-  expect(document.createElement).toHaveBeenCalledTimes(1);
-});

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

@@ -1,13 +0,0 @@
-import { isFileProtocol } from './protocol';
-test('should return true when location url contains file protocol', () => {
-  jest.spyOn(window, 'location', 'get').mockReturnValue({
-    protocol: 'file:'
-  });
-  expect(isFileProtocol()).toEqual(true);
-});
-test('should return false when location url does not contains file protocol', () => {
-  jest.spyOn(window, 'location', 'get').mockReturnValue({
-    protocol: 'http:'
-  });
-  expect(isFileProtocol()).toEqual(false);
-});

package/dist/esm/common/util/console.test.js

@@ -1,28 +0,0 @@
-import { warn } from './console';
-beforeEach(() => {
-  console.warn = jest.fn();
-});
-afterEach(() => {
-  jest.restoreAllMocks();
-});
-describe('warn', () => {
-  test('should not call console.warn if it is not a function', () => {
-    const spy = jest.spyOn(console, 'warn');
-    console.warn = undefined;
-    warn('test message');
-    expect(spy).not.toHaveBeenCalled();
-  });
-  test('should call console.warn with a prefixed message', () => {
-    warn('test message');
-    expect(console.warn).toHaveBeenCalledWith('New Relic: test message');
-  });
-  test('should call console.warn with secondary argument if provided', () => {
-    const secondary = 'secondary value';
-    warn('test message', secondary);
-    expect(console.warn).toHaveBeenCalledWith(secondary);
-  });
-  test('should not call console.warn with secondary argument if not provided', () => {
-    warn('test message');
-    expect(console.warn).toHaveBeenCalledTimes(1);
-  });
-});

package/dist/esm/common/util/data-size.test.js

@@ -1,60 +0,0 @@
-import { faker } from '@faker-js/faker';
-import * as stringifyModule from './stringify';
-import { dataSize } from './data-size';
-jest.mock('./stringify');
-describe('dataSize', () => {
-  test('returns length of string', () => {
-    const str = faker.lorem.sentence();
-    expect(dataSize(str)).toBe(str.length);
-  });
-  test('returns undefined for non-object, number, or empty string', () => {
-    expect(dataSize(Infinity)).toBeUndefined();
-    expect(dataSize(NaN)).toBeUndefined();
-    expect(dataSize(12345)).toBeUndefined();
-    expect(dataSize('')).toBeUndefined();
-  });
-  test('returns byte length of ArrayBuffer object', () => {
-    const buffer = new ArrayBuffer(faker.datatype.number({
-      min: 10,
-      max: 100
-    }));
-    expect(dataSize(buffer)).toBe(buffer.byteLength);
-  });
-  test('returns size of Blob object', () => {
-    const blob = new Blob([faker.lorem.sentence()], {
-      type: 'text/plain'
-    });
-    expect(dataSize(blob)).toBe(blob.size);
-  });
-  test('returns undefined for FormData object', () => {
-    const formData = new FormData();
-    expect(dataSize(formData)).toBeUndefined();
-  });
-  test('uses stringify to get the length of an object', () => {
-    const input = {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    };
-    const expectedSize = faker.datatype.number({
-      min: 1000,
-      max: 10000
-    });
-    jest.spyOn(stringifyModule, 'stringify').mockReturnValue({
-      length: expectedSize
-    });
-    expect(dataSize(input)).toBe(expectedSize);
-  });
-  test('should not throw an exception if stringify throws an exception', () => {
-    const input = {
-      [faker.datatype.uuid()]: faker.lorem.sentence()
-    };
-    const expectedSize = faker.datatype.number({
-      min: 1000,
-      max: 10000
-    });
-    jest.spyOn(stringifyModule, 'stringify').mockImplementation(() => {
-      throw new Error(faker.lorem.sentence());
-    });
-    expect(() => dataSize(input)).not.toThrow();
-    expect(dataSize(input)).toBeUndefined();
-  });
-});

package/dist/esm/common/util/feature-flags.test.js

@@ -1,80 +0,0 @@
-import { faker } from '@faker-js/faker';
-import * as eventEmitterModule from '../event-emitter/contextual-ee';
-import * as handleModule from '../event-emitter/handle';
-import * as drainModule from '../drain/drain';
-import { activateFeatures, activatedFeatures } from './feature-flags';
-import { FEATURE_NAMES } from '../../loaders/features/features';
-jest.mock('../event-emitter/handle');
-jest.mock('../drain/drain');
-jest.mock('../event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  ee: {
-    get: jest.fn(() => ({
-      foo: "bar_".concat(Math.random())
-    }))
-  }
-}));
-let agentIdentifier;
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid();
-});
-afterEach(() => {
-  Object.keys(activatedFeatures).forEach(key => delete activatedFeatures[key]);
-});
-test.each([null, undefined])('should not do anything when flags is %s', input => {
-  activateFeatures(input, agentIdentifier);
-  expect(handleModule.handle).not.toHaveBeenCalled();
-  expect(drainModule.drain).not.toHaveBeenCalled();
-  expect(activatedFeatures).toEqual({});
-});
-const bucketMap = {
-  stn: [FEATURE_NAMES.sessionTrace],
-  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
-  ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa],
-  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
-};
-test('emits the right events when feature flag = 1', () => {
-  const flags = {};
-  Object.keys(bucketMap).forEach(flag => flags[flag] = 1);
-  activateFeatures(flags, agentIdentifier);
-  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
-
-  // each flag gets emitted to each of its mapped features, and a feat- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
-  expect(handleModule.handle).toHaveBeenCalledTimes(14);
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [true], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
-  Object.keys(flags).forEach(flag => flags[flag] = true);
-  expect(activatedFeatures).toEqual(flags);
-});
-test('emits the right events when feature flag = 0', () => {
-  const flags = {};
-  Object.keys(bucketMap).forEach(flag => flags[flag] = 0);
-  activateFeatures(flags, agentIdentifier);
-  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
-
-  // each flag gets emitted to each of its mapped features, and a block- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
-  expect(handleModule.handle).toHaveBeenCalledTimes(14);
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'block-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [false], undefined, FEATURE_NAMES.sessionTrace, sharedEE);
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
-  Object.keys(flags).forEach(flag => flags[flag] = false);
-  expect(activatedFeatures).toEqual(flags);
-});
-test('only the first activate of the same feature is respected', () => {
-  const flags = {
-    stn: 1
-  };
-  activateFeatures(flags, agentIdentifier);
-  flags.stn = 0;
-  activateFeatures(flags, agentIdentifier);
-  const sharedEE1 = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value;
-  const sharedEE2 = jest.mocked(eventEmitterModule.ee.get).mock.results[1].value;
-  expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE1);
-  expect(handleModule.handle).toHaveBeenNthCalledWith(2, 'rumresp-stn', [true], undefined, 'session_trace', sharedEE1);
-  expect(handleModule.handle).not.toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE2);
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event');
-  expect(drainModule.drain).toHaveBeenCalledTimes(2);
-  expect(activatedFeatures.stn).toBeTruthy();
-});

package/dist/esm/common/util/get-or-set.test.js

@@ -1,45 +0,0 @@
-import { getOrSet } from './get-or-set';
-test('should return the current value of an existing property', () => {
-  const obj = {
-    foo: 'bar'
-  };
-  const prop = 'foo';
-  const getVal = jest.fn();
-  const result = getOrSet(obj, prop, getVal);
-  expect(result).toBe('bar');
-  expect(getVal).not.toHaveBeenCalled();
-});
-test('should set and return the value from getVal if the property does not exist', () => {
-  const obj = {};
-  const prop = 'foo';
-  const getVal = jest.fn().mockReturnValue('baz');
-  const result = getOrSet(obj, prop, getVal);
-  expect(result).toBe('baz');
-  expect(getVal).toHaveBeenCalled();
-  expect(obj.foo).toBe('baz');
-});
-test('should set the property as non-enumerable if Object.defineProperty is supported', () => {
-  const obj = {};
-  const prop = 'foo';
-  const getVal = jest.fn().mockReturnValue('baz');
-  jest.spyOn(Object, 'defineProperty');
-  const result = getOrSet(obj, prop, getVal);
-  expect(result).toBe('baz');
-  expect(Object.defineProperty).toHaveBeenCalledWith(obj, prop, {
-    value: 'baz',
-    writable: true,
-    enumerable: false
-  });
-});
-test('should set the property from getVal if Object.defineProperty and Object.keys are not supported', () => {
-  const obj = {};
-  const prop = 'foo';
-  const getVal = jest.fn(() => 'baz');
-  const originalFn = Object.defineProperty;
-  Object.defineProperty = null;
-  const result = getOrSet(obj, prop, getVal);
-  expect(result).toBe('baz');
-  expect(obj.foo).toBe('baz');
-  expect(Object.prototype.propertyIsEnumerable.call(obj, 'foo')).toBe(true);
-  Object.defineProperty = originalFn;
-});

package/dist/esm/common/util/global-scope.js

@@ -1,17 +0,0 @@
-/* global globalThis, WorkerGlobalScope, WorkerNavigator */
-
-export const isBrowserScope = Boolean(typeof window !== 'undefined' && window.document);
-export const isWorkerScope = Boolean(typeof WorkerGlobalScope !== 'undefined' && self.navigator instanceof WorkerNavigator);
-export let globalScope = (() => {
-  if (isBrowserScope) {
-    return window;
-  } else if (isWorkerScope) {
-    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
-      return globalThis;
-    } else if (self instanceof WorkerGlobalScope) {
-      return self;
-    }
-  }
-  throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".');
-})();
-export const initialLocation = '' + globalScope.location;

package/dist/esm/common/util/global-scope.test.js

@@ -1,70 +0,0 @@
-/*
-The global-scope module contains exports that are defined once at the time
-of importing the module. For this reason, the module must be dynamically
-imported in each test case.
-
-A scope must always exist or importing the module will throw an error. Use
-`enableWorkerScope` to enable the worker scope. Be sure to call `disableWorkerScope`
-before any calls to `expect` or the test will fail with an error from Jest.
-*/
-
-import { faker } from '@faker-js/faker';
-afterEach(() => {
-  jest.restoreAllMocks();
-  jest.resetModules();
-});
-test('should indicate a browser scope', async () => {
-  jest.spyOn(global, 'window', 'get').mockReturnValue({
-    document: {}
-  });
-  const globalScopeModule = await import('./global-scope');
-  expect(globalScopeModule.isBrowserScope).toBe(true);
-  expect(globalScopeModule.isWorkerScope).toBe(false);
-  expect(globalScopeModule.globalScope).toBe(global.window);
-});
-test('should indicate a worker scope', async () => {
-  enableWorkerScope();
-  const globalScopeModule = await import('./global-scope');
-  const mockedGlobalThis = global.globalThis;
-  disableWorkerScope();
-  expect(globalScopeModule.isBrowserScope).toBe(false);
-  expect(globalScopeModule.isWorkerScope).toBe(true);
-  expect(globalScopeModule.globalScope).toBe(mockedGlobalThis);
-});
-test('should return the self global', async () => {
-  enableWorkerScope();
-  jest.replaceProperty(global, 'globalThis', null);
-  jest.spyOn(global, 'self', 'get').mockReturnValue(new global.WorkerGlobalScope());
-  const globalScopeModule = await import('./global-scope');
-  const mockedGlobalSelf = global.self;
-  disableWorkerScope();
-  expect(globalScopeModule.isBrowserScope).toBe(false);
-  expect(globalScopeModule.isWorkerScope).toBe(true);
-  expect(globalScopeModule.globalScope).toBe(mockedGlobalSelf);
-});
-test('should throw an error when a scope cannot be defined', async () => {
-  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined);
-  await expect(() => import('./global-scope')).rejects.toThrow();
-});
-test('should immediately store the current location', async () => {
-  const url = faker.internet.url();
-  jest.spyOn(window, 'location', 'get').mockReturnValue(url);
-  const globalScopeModule = await import('./global-scope');
-  expect(globalScopeModule.initialLocation).toBe(url);
-});
-function enableWorkerScope() {
-  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined);
-  class WorkerNavigator {}
-  class WorkerGlobalScope {
-    navigator = new WorkerNavigator();
-  }
-  global.WorkerGlobalScope = WorkerGlobalScope;
-  global.WorkerNavigator = WorkerNavigator;
-  jest.spyOn(global, 'navigator', 'get').mockReturnValue(new global.WorkerNavigator());
-  jest.replaceProperty(global, 'globalThis', new WorkerGlobalScope());
-}
-function disableWorkerScope() {
-  delete global.WorkerGlobalScope;
-  delete global.WorkerNavigator;
-  jest.restoreAllMocks();
-}

package/dist/esm/common/util/invoke.test.js

@@ -1,47 +0,0 @@
-import { debounce, single } from './invoke';
-jest.useFakeTimers();
-describe('debounce', () => {
-  test('should run the supplied function after 100ms', () => {
-    let mockCallback = jest.fn();
-    let debouncedMethod = debounce(mockCallback, 100);
-    execFnTimes(debouncedMethod, 100);
-    expect(mockCallback).not.toHaveBeenCalled();
-    jest.advanceTimersByTime(1000);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-  });
-  test('should rerun the supplied function when called again after 100ms', () => {
-    let mockCallback = jest.fn();
-    let debouncedMethod = debounce(mockCallback, 100);
-    execFnTimes(debouncedMethod, 100);
-    jest.advanceTimersByTime(200);
-    execFnTimes(debouncedMethod, 100);
-    jest.advanceTimersByTime(2000);
-    expect(mockCallback).toHaveBeenCalledTimes(2);
-  });
-  test('should run the supplied function on the first event and debounce subsequent events', () => {
-    let mockCallback = jest.fn();
-    let debouncedMethod = debounce(mockCallback, 100, {
-      leading: true
-    });
-    execFnTimes(debouncedMethod, 100);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-    jest.advanceTimersByTime(200);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-    execFnTimes(debouncedMethod, 100);
-    jest.advanceTimersByTime(200);
-    expect(mockCallback).toHaveBeenCalledTimes(2);
-  });
-});
-describe('single', () => {
-  test('should run the supplied function only once', () => {
-    let mockCallback = jest.fn();
-    let singleMethod = single(mockCallback, 100);
-    execFnTimes(singleMethod, 100);
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-  });
-});
-function execFnTimes(fn, count) {
-  for (let i = 0; i < count; i++) {
-    fn();
-  }
-}

package/dist/esm/common/util/map-own.test.js

@@ -1,47 +0,0 @@
-import { mapOwn } from './map-own';
-test('enumerates the object properties', () => {
-  const callback = jest.fn();
-  const input = {
-    foo: 'bar'
-  };
-  mapOwn(input, callback);
-  expect(callback).toHaveBeenCalledWith('foo', 'bar');
-});
-test('return array of results from callback invocation', () => {
-  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
-  const input = {
-    foo: 'bar',
-    biz: 'baz'
-  };
-  const result = mapOwn(input, callback);
-  expect(result.length).toEqual(2);
-  expect(result).toContain('foo:bar');
-  expect(result).toContain('biz:baz');
-});
-test('does not iterate symbol properties', () => {
-  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
-  const input = {
-    foo: 'bar',
-    [Symbol.for('biz')]: 'baz'
-  };
-  const result = mapOwn(input, callback);
-  expect(result.length).toEqual(1);
-});
-test('does not iterate inherited properties', () => {
-  function F() {}
-  F.prototype = {
-    biz: 'baz'
-  };
-  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
-  const input = new F();
-  input.foo = 'bar';
-  const result = mapOwn(input, callback);
-  expect(result.length).toEqual(1);
-});
-test.each([null, undefined])('returns empty array when passed object is null or undefined', input => {
-  const callback = jest.fn();
-  const result = mapOwn(input, callback);
-  expect(Array.isArray(result)).toEqual(true);
-  expect(result.length).toEqual(0);
-  expect(callback).toHaveBeenCalledTimes(0);
-});

package/dist/esm/common/util/obfuscate.component-test.js

@@ -1,125 +0,0 @@
-import { faker } from '@faker-js/faker';
-import * as configModule from '../config/config';
-import * as urlProtocolModule from '../url/protocol';
-import * as consolModule from './console';
-import * as obfuscateModule from './obfuscate';
-jest.mock('../config/config');
-jest.mock('../context/shared-context');
-jest.mock('../url/protocol');
-jest.mock('./console');
-let agentIdentifier;
-const rules = [{
-  regex: /pii/g,
-  replacement: 'OBFUSCATED'
-}];
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid();
-});
-afterEach(() => {
-  jest.resetAllMocks();
-});
-describe('Obfuscator', () => {
-  test('shouldObfuscate returns true when there are rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
-    const obfuscator = new obfuscateModule.Obfuscator();
-    obfuscator.sharedContext = {
-      agentIdentifier
-    };
-    expect(obfuscator.shouldObfuscate()).toEqual(true);
-  });
-  test('shouldObfuscate returns false when there are no rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([]);
-    const obfuscator = new obfuscateModule.Obfuscator();
-    obfuscator.sharedContext = {
-      agentIdentifier
-    };
-    expect(obfuscator.shouldObfuscate()).toEqual(false);
-  });
-  test('obfuscateString returns the input when there are no rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue([]);
-    const input = faker.lorem.sentence();
-    const obfuscator = new obfuscateModule.Obfuscator();
-    obfuscator.sharedContext = {
-      agentIdentifier
-    };
-    expect(obfuscator.obfuscateString(input)).toEqual(input);
-  });
-  test('obfuscateString applies obfuscation rules to input', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
-    const input = 'pii';
-    const obfuscator = new obfuscateModule.Obfuscator();
-    obfuscator.sharedContext = {
-      agentIdentifier
-    };
-    expect(obfuscator.obfuscateString(input)).toEqual(rules[0].replacement);
-  });
-  test('obfuscateString replaces input with * when replacement is not set', () => {
-    const newRules = [{
-      regex: rules[0].regex
-    }];
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(newRules);
-    const input = 'pii';
-    const obfuscator = new obfuscateModule.Obfuscator();
-    obfuscator.sharedContext = {
-      agentIdentifier
-    };
-    expect(obfuscator.obfuscateString(input)).toEqual('*');
-  });
-  test.each([null, undefined, '', 123])('obfuscateString returns the input it is %s', input => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
-    const obfuscator = new obfuscateModule.Obfuscator();
-    obfuscator.sharedContext = {
-      agentIdentifier
-    };
-    expect(obfuscator.obfuscateString(input)).toEqual(input);
-  });
-});
-describe('getRules', () => {
-  test('should return configured rules', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
-    expect(obfuscateModule.getRules()).toEqual(rules);
-  });
-  test('should include the file protocol obfuscation', () => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(rules);
-    jest.spyOn(urlProtocolModule, 'isFileProtocol').mockReturnValue(rules);
-    expect(obfuscateModule.getRules()).toEqual(expect.arrayContaining([{
-      regex: /^file:\/\/(.*)/,
-      replacement: 'file://OBFUSCATED'
-    }]));
-  });
-  test.each([null, undefined])('should return an empty array when obfuscation rules are %s', input => {
-    jest.spyOn(configModule, 'getConfigurationValue').mockReturnValue(input);
-    expect(obfuscateModule.getRules()).toEqual([]);
-  });
-});
-describe('validateRules', () => {
-  test('should return true for empty array', () => {
-    expect(obfuscateModule.validateRules([])).toEqual(true);
-  });
-  test('should return true for valid rules', () => {
-    expect(obfuscateModule.validateRules(rules)).toEqual(true);
-  });
-  test.each([null, 123, {}, []])('should warn about an invalid regex type %s', input => {
-    const newRules = [{
-      regex: input,
-      replacement: rules[0].replacement
-    }];
-    expect(obfuscateModule.validateRules(newRules)).toEqual(false);
-    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining('contains a "regex" value with an invalid type'));
-  });
-  test('should warn about a missing regex with value', () => {
-    const newRules = [{
-      replacement: rules[0].replacement
-    }];
-    expect(obfuscateModule.validateRules(newRules)).toEqual(false);
-    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining('missing a "regex" value'));
-  });
-  test.each([123, {}, []])('should warn about an invalid replacement type %s', input => {
-    const newRules = [{
-      regex: rules[0].regex,
-      replacement: input
-    }];
-    expect(obfuscateModule.validateRules(newRules)).toEqual(false);
-    expect(consolModule.warn).toHaveBeenCalledWith(expect.stringContaining('contains a "replacement" value with an invalid type'));
-  });
-});