@newrelic/browser-agent 1.232.0 → 1.233.0

package/dist/esm/features/jserrors/aggregate/compute-stack-trace.test.js

@@ -1,14 +1,27 @@
 import { faker } from '@faker-js/faker';
 import { browserErrorUtils } from '../../../../tools/testing-utils';
-import { computeStackTrace } from './compute-stack-trace';
+const globalScopeLocation = 'https://example.com/';
+const mockGlobalScopeLocation = url => {
+  jest.doMock('../../../common/util/global-scope', () => ({
+    initialLocation: url || globalScopeLocation
+  }));
+};
+afterEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
 const baseMockError = {
   toString: 'RangeError: Invalid array length',
   name: 'RangeError',
   constructor: 'function RangeError() { [native code] }',
   message: 'Invalid array length',
-  stack: 'RangeError: Invalid array length\n    at errorTest (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:74:16)\n    at captureError (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:17:9)\n    at onload (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:70:5)'
+  stack: 'RangeError: Invalid array length\n' + '    at errorTest (' + globalScopeLocation + '?loader=spa#hello:74:16)\n' + '    at captureError (' + globalScopeLocation + 'js/script.js?loader=spa:17:9)\n' + '    at onload (' + globalScopeLocation + 'js/script.js?loader=spa:70:5)'
 };
-test('parsing should return a failure for a null error object', () => {
+test('parsing should return a failure for a null error object', async () => {
+  mockGlobalScopeLocation();
+  const {
+    computeStackTrace
+  } = await import('./compute-stack-trace');
   const result = computeStackTrace(null);
   expect(result).toEqual(expect.objectContaining({
     mode: 'failed',
@@ -17,24 +30,45 @@ test('parsing should return a failure for a null error object', () => {
   }));
 });
 describe('errors with stack property', () => {
-  test('parsed name should be unknown when name and constructor are missing', () => {
+  test('should show <inline> for same-page stack string URLs but not sub-paths', async () => {
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError
+    });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
+    const result = computeStackTrace(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      stackString:
+      // canonicalized
+      'RangeError: Invalid array length\n' + '    at errorTest (<inline>:74:16)\n' + '    at captureError (' + globalScopeLocation + 'js/script.js:17:9)\n' + '    at onload (' + globalScopeLocation + 'js/script.js:70:5)'
+    }));
+  });
+  test('parsed name should be unknown when name and constructor are missing', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       name: null,
       constructor: null
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
-      name: 'unknown',
-      message: mockError.message,
-      stackString: mockError.stack
+      name: 'unknown'
     }));
   });
-  test('parsed stack should not contain nrWrapper', () => {
+  test('parsed stack should not contain nrWrapper', async () => {
     const alteredError = baseMockError;
-    alteredError.stack += '\n    at nrWrapper (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:60:17)';
+    alteredError.stack += '\n    at nrWrapper (' + globalScopeLocation + '?loader=spa:60:17)';
     const mockError = browserErrorUtils.constructError(alteredError);
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -46,17 +80,21 @@ describe('errors with stack property', () => {
       func: 'nrWrapper'
     }));
   });
-  test('stack should still parse when column numbers are missing', () => {
+  test('stack should still parse when column numbers are missing', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
-      stack: 'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n    at errorTest (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:60)\n    at captureError (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:17)\n    at onload (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:57)'
+      stack: 'RangeError: Invalid array length\n' + 'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n' + '    at errorTest (' + globalScopeLocation + '?loader=spa:60)\n' + '    at captureError (' + globalScopeLocation + '?loader=spa:17)\n' + '    at onload (' + globalScopeLocation + '?loader=spa:57)'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
       name: mockError.name,
       message: mockError.message,
-      stackString: mockError.stack
+      stackString: 'RangeError: Invalid array length\n' + 'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n' + '    at errorTest (<inline>:60)\n' + '    at captureError (<inline>:17)\n' + '    at onload (<inline>:57)'
     }));
     expect(result.frames.length).toEqual(3);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -72,11 +110,15 @@ describe('errors with stack property', () => {
       column: null
     }));
   });
-  test('parser can handle chrome eval stack', () => {
+  test('parser can handle chrome eval stack', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
-      stack: '    at foobar (eval at foobar (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html))'
+      stack: '    at foobar (eval at foobar (' + globalScopeLocation + '))'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -89,7 +131,7 @@ describe('errors with stack property', () => {
       func: 'evaluated code'
     }));
   });
-  test('parser can handle ie eval stack', () => {
+  test('parser can handle ie eval stack', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: 'TypeError: Permission denied',
       name: 'TypeError',
@@ -97,6 +139,10 @@ describe('errors with stack property', () => {
       message: 'Permission denied',
       stack: '    at Function code (Function code:23:23)'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -109,11 +155,15 @@ describe('errors with stack property', () => {
       func: 'evaluated code'
     }));
   });
-  test('parser can handle stack with anonymous function', () => {
+  test('parser can handle stack with anonymous function', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       stack: 'anonymous'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
@@ -131,7 +181,7 @@ describe('errors without stack property and with line property', () => {
   /**
    * @deprecated sourceURL is no longer present in errors for any browsers we support
    */
-  test('parsed stack should contain sourceURL and line number', () => {
+  test('parsed stack should contain sourceURL and line number', async () => {
     const sourceURL = faker.internet.url();
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
@@ -139,6 +189,10 @@ describe('errors without stack property and with line property', () => {
       line: 100,
       sourceURL
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'sourceline',
@@ -156,7 +210,7 @@ describe('errors without stack property and with line property', () => {
   /**
    * @deprecated sourceURL is no longer present in errors for any browsers we support
    */
-  test('parsed stack should contain sourceURL, line number, and column number', () => {
+  test('parsed stack should contain sourceURL, line number, and column number', async () => {
     const sourceURL = faker.internet.url();
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
@@ -165,6 +219,10 @@ describe('errors without stack property and with line property', () => {
       stack: undefined,
       sourceURL
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'sourceline',
@@ -179,13 +237,17 @@ describe('errors without stack property and with line property', () => {
       column: mockError.column
     }));
   });
-  test('parsed stack should contain "evaluated code" if sourceURL property is not present', () => {
+  test('parsed stack should contain "evaluated code" if sourceURL property is not present', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       line: 100,
       column: 200,
       stack: undefined
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'sourceline',
@@ -199,6 +261,58 @@ describe('errors without stack property and with line property', () => {
     }));
   });
 
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('should show <inline> for same-page URLs', async () => {
+    const pageLocation = faker.internet.url();
+    const sourceURL = pageLocation + '?abc=123';
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL: sourceURL
+    });
+    mockGlobalScopeLocation(pageLocation);
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
+    const result = computeStackTrace(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at <inline>:").concat(mockError.line, ":").concat(mockError.column)
+    }));
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: '<inline>'
+    }));
+  });
+
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('should NOT show <inline> for same-domain URLs with a sub-path', async () => {
+    const pageLocation = faker.internet.url();
+    const sourceURL = pageLocation + '/path/to/script.js';
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL
+    });
+    mockGlobalScopeLocation(pageLocation);
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
+    const result = computeStackTrace(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at ").concat(sourceURL, ":").concat(mockError.line, ":").concat(mockError.column)
+    }));
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: sourceURL
+    }));
+  });
+
   // TODO: computeStackTraceBySourceAndLine does not respect firefox lineNumber and columnNumber properties when stack is empty
 });
 
@@ -207,11 +321,15 @@ describe('errors without stack property and with line property', () => {
  * error, including primitives.
  */
 describe('errors that are messages only or primitives', () => {
-  test('parser should get error name from constructor', () => {
+  test('parser should get error name from constructor', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       constructor: 'function Number() { [native code] }'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
@@ -220,12 +338,16 @@ describe('errors that are messages only or primitives', () => {
       frames: []
     }));
   });
-  test('parser should get error name from name property', () => {
+  test('parser should get error name from name property', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       name: faker.datatype.uuid(),
       constructor: 'function Number() { [native code] }'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
@@ -234,13 +356,17 @@ describe('errors that are messages only or primitives', () => {
       frames: []
     }));
   });
-  test('parser should include the message property', () => {
+  test('parser should include the message property', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       name: faker.datatype.uuid(),
       message: faker.datatype.uuid(),
       constructor: 'function Number() { [native code] }'
     });
+    mockGlobalScopeLocation();
+    const {
+      computeStackTrace
+    } = await import('./compute-stack-trace');
     const result = computeStackTrace(mockError);
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
@@ -250,6 +376,4 @@ describe('errors that are messages only or primitives', () => {
       frames: []
     }));
   });
-});
-
-// describe('')
+});

package/dist/esm/features/jserrors/aggregate/index.js

@@ -4,7 +4,6 @@
  */
 
 import { canonicalFunctionName } from './canonical-function-name';
-import { cleanURL } from '../../../common/url/clean-url';
 import { computeStackTrace } from './compute-stack-trace';
 import { stringHashCode } from './string-hash-code';
 import { truncateSize } from './format-stack-trace';
@@ -19,8 +18,13 @@ import { globalScope } from '../../../common/util/global-scope';
 import { FEATURE_NAME } from '../constants';
 import { drain } from '../../../common/drain/drain';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { FeatureBase } from '../../utils/feature-base';
-export class Aggregate extends FeatureBase {
+import { AggregateBase } from '../../utils/aggregate-base';
+
+/**
+ * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
+ */
+
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     var _this;
@@ -103,49 +107,25 @@ export class Aggregate extends FeatureBase {
   getBucketName(params, customParams) {
     return this.nameHash(params) + ':' + stringHashCode(stringify(customParams));
   }
-  canonicalizeURL(url, cleanedOrigin) {
-    if (typeof url !== 'string') return '';
-    var cleanedURL = cleanURL(url);
-    if (cleanedURL === cleanedOrigin) {
-      return '<inline>';
-    } else {
-      return cleanedURL;
-    }
-  }
-  buildCanonicalStackString(stackInfo, cleanedOrigin) {
-    var canonicalStack = '';
-    for (var i = 0; i < stackInfo.frames.length; i++) {
-      var frame = stackInfo.frames[i];
-      var func = canonicalFunctionName(frame.func);
-      if (canonicalStack) canonicalStack += '\n';
-      if (func) canonicalStack += func + '@';
-      if (typeof frame.url === 'string') canonicalStack += frame.url;
-      if (frame.line) canonicalStack += ':' + frame.line;
-    }
-    return canonicalStack;
-  }
 
-  // Strip query parameters and fragments from the stackString property of the
-  // given stackInfo, along with the 'url' properties of each frame in
-  // stackInfo.frames.
-  //
-  // Any URLs that are equivalent to the cleaned version of the origin will also
-  // be replaced with the string '<inline>'.
-  //
-  canonicalizeStackURLs(stackInfo) {
-    // Currently, loader.origin might contain a fragment, but we don't want to use it
-    // for comparing with frame URLs.
-    var cleanedOrigin = cleanURL(getRuntime(this.agentIdentifier).origin);
+  /**
+   * Builds a standardized stack trace string from the frames in the given `stackInfo` object, with each frame separated
+   * by a newline character. Lines take the form `<functionName>@<url>:<lineNumber>`.
+   *
+   * @param {StackInfo} stackInfo - An object specifying a stack string and individual frames.
+   * @returns {string} A canonical stack string built from the URLs and function names in the given `stackInfo` object.
+   */
+  buildCanonicalStackString(stackInfo) {
+    var canonicalStackString = '';
     for (var i = 0; i < stackInfo.frames.length; i++) {
       var frame = stackInfo.frames[i];
-      var originalURL = frame.url;
-      var cleanedURL = this.canonicalizeURL(originalURL, cleanedOrigin);
-      if (cleanedURL && cleanedURL !== frame.url) {
-        frame.url = cleanedURL;
-        stackInfo.stackString = stackInfo.stackString.split(originalURL).join(cleanedURL);
-      }
+      var func = canonicalFunctionName(frame.func);
+      if (canonicalStackString) canonicalStackString += '\n';
+      if (func) canonicalStackString += func + '@';
+      if (typeof frame.url === 'string') canonicalStackString += frame.url;
+      if (frame.line) canonicalStackString += ':' + frame.line;
     }
-    return stackInfo;
+    return canonicalStackString;
   }
   storeError(err, time, internal, customAttributes) {
     // are we in an interaction
@@ -162,10 +142,10 @@ export class Aggregate extends FeatureBase {
       // Again as with previous usage, all falsey values would include the error.
     }
 
-    var stackInfo = this.canonicalizeStackURLs(computeStackTrace(err));
-    var canonicalStack = this.buildCanonicalStackString(stackInfo);
+    var stackInfo = computeStackTrace(err);
+    var canonicalStackString = this.buildCanonicalStackString(stackInfo);
     const params = {
-      stackHash: stringHashCode(canonicalStack),
+      stackHash: stringHashCode(canonicalStackString),
       exceptionClass: stackInfo.name,
       request_uri: globalScope?.location.pathname
     };
@@ -203,10 +183,12 @@ export class Aggregate extends FeatureBase {
       time: time
     };
 
-    // stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
     // and spa annotates the error with interaction info
-    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, FEATURE_NAMES.sessionTrace, this.ee);
-    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, FEATURE_NAMES.spa, this.ee);
+    const msg = [type, bucketHash, params, newMetrics];
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionTrace, this.ee);
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.spa, this.ee);
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionReplay, this.ee);
 
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;

package/dist/esm/features/jserrors/instrument/index.js

@@ -7,7 +7,6 @@ import { handle } from '../../../common/event-emitter/handle';
 import { now } from '../../../common/timing/now';
 import { getOrSet } from '../../../common/util/get-or-set';
 import { wrapRaf, wrapTimer, wrapEvents, wrapXhr } from '../../../common/wrap';
-import slice from 'lodash._slice';
 import './debug';
 import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME, NR_ERR_PROP } from '../constants';

package/dist/esm/features/metrics/aggregate/framework-detection.js

@@ -0,0 +1,61 @@
+import { isBrowserScope } from '../../../common/util/global-scope';
+const FRAMEWORKS = {
+  REACT: 'React',
+  ANGULAR: 'Angular',
+  ANGULARJS: 'AngularJS',
+  BACKBONE: 'Backbone',
+  EMBER: 'Ember',
+  VUE: 'Vue',
+  METEOR: 'Meteor',
+  ZEPTO: 'Zepto',
+  JQUERY: 'Jquery',
+  MOOTOOLS: 'MooTools'
+};
+export function getFrameworks() {
+  if (!isBrowserScope) return []; // don't bother detecting frameworks if not in the main window context
+
+  const frameworks = [];
+  try {
+    if (detectReact()) frameworks.push(FRAMEWORKS.REACT);
+    if (detectAngularJs()) frameworks.push(FRAMEWORKS.ANGULARJS);
+    if (detectAngular()) frameworks.push(FRAMEWORKS.ANGULAR);
+    if (Object.prototype.hasOwnProperty.call(window, 'Backbone')) frameworks.push(FRAMEWORKS.BACKBONE);
+    if (Object.prototype.hasOwnProperty.call(window, 'Ember')) frameworks.push(FRAMEWORKS.EMBER);
+    if (Object.prototype.hasOwnProperty.call(window, 'Vue')) frameworks.push(FRAMEWORKS.VUE);
+    if (Object.prototype.hasOwnProperty.call(window, 'Meteor')) frameworks.push(FRAMEWORKS.METEOR);
+    if (Object.prototype.hasOwnProperty.call(window, 'Zepto')) frameworks.push(FRAMEWORKS.ZEPTO);
+    if (Object.prototype.hasOwnProperty.call(window, 'jQuery')) frameworks.push(FRAMEWORKS.JQUERY);
+    if (Object.prototype.hasOwnProperty.call(window, 'MooTools')) frameworks.push(FRAMEWORKS.MOOTOOLS);
+  } catch (err) {
+    // Possibly not supported
+  }
+  return frameworks;
+}
+function detectReact() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'React') || Object.prototype.hasOwnProperty.call(window, 'ReactDOM') || Object.prototype.hasOwnProperty.call(window, 'ReactRedux') || document.querySelector('[data-reactroot], [data-reactid]') || (() => {
+      const divs = document.querySelectorAll('body > div');
+      for (let i = 0; i < divs.length; i++) {
+        if (Object.prototype.hasOwnProperty.call(divs[i], '_reactRootContainer')) {
+          return true;
+        }
+      }
+    })();
+  } catch (err) {
+    return false;
+  }
+}
+function detectAngularJs() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'angular') || document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]') || document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]');
+  } catch (err) {
+    return false;
+  }
+}
+function detectAngular() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'ng') || document.querySelector('[ng-version]');
+  } catch (err) {
+    return false;
+  }
+}

package/dist/esm/features/metrics/aggregate/framework-detection.test.js

@@ -0,0 +1,133 @@
+import { faker } from '@faker-js/faker';
+import { getFrameworks } from './framework-detection';
+jest.mock('../../../common/util/global-scope', () => ({
+  isBrowserScope: true
+}));
+afterEach(() => {
+  document.body.innerHTML = '';
+});
+test('framework detection should not happen in non-browser scope', async () => {
+  global.React = {};
+  jest.resetModules();
+  jest.doMock('../../../common/util/global-scope', () => ({
+    isBrowserScope: false
+  }));
+  const frameworkDetector = await import('./framework-detection');
+  expect(frameworkDetector.getFrameworks()).toEqual([]);
+  delete global.React;
+});
+test('should detect react from global React property', () => {
+  global.React = {};
+  expect(getFrameworks()).toEqual(['React']);
+  delete global.React;
+});
+test('should detect react from global ReactDOM property', () => {
+  global.ReactDOM = {};
+  expect(getFrameworks()).toEqual(['React']);
+  delete global.ReactDOM;
+});
+test('should detect react from global ReactRedux property', () => {
+  global.ReactRedux = {};
+  expect(getFrameworks()).toEqual(['React']);
+  delete global.ReactRedux;
+});
+test('should detect react from html [data-reactroot] property', () => {
+  document.body.innerHTML = '<div data-reactroot=""></div>';
+  expect(getFrameworks()).toEqual(['React']);
+});
+test('should detect react from html [data-reactid] property', () => {
+  document.body.innerHTML = '<div data-reactid=""></div>';
+  expect(getFrameworks()).toEqual(['React']);
+});
+test('should detect react from element _reactRootContainer property', () => {
+  const element = document.createElement('div');
+  element._reactRootContainer = {};
+  document.body.innerHTML = '<html><body></body></html>';
+  document.body.appendChild(element);
+  expect(getFrameworks()).toEqual(['React']);
+});
+test('should detect angularjs from global angular property', () => {
+  global.angular = {};
+  expect(getFrameworks()).toEqual(['AngularJS']);
+  delete global.angular;
+});
+test('should detect angularjs from html .ng-binding property', () => {
+  document.body.innerHTML = '<div class="ng-binding"></div>';
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [ng-app] property', () => {
+  document.body.innerHTML = '<div ng-app=""></div>';
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [data-ng-app] property', () => {
+  document.body.innerHTML = '<div data-ng-app=""></div>';
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [ng-controller] property', () => {
+  document.body.innerHTML = '<div ng-controller=""></div>';
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [data-ng-controller] property', () => {
+  document.body.innerHTML = '<div data-ng-controller=""></div>';
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [ng-repeat] property', () => {
+  document.body.innerHTML = '<div ng-repeat=""></div>';
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from html [data-ng-repeat] property', () => {
+  document.body.innerHTML = '<div data-ng-repeat=""></div>';
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from angular.js script element', () => {
+  document.body.innerHTML = "<script src=\"".concat(faker.internet.url(), "/angular.js\"></script>");
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angularjs from angular.min.js script element', () => {
+  document.body.innerHTML = "<script src=\"".concat(faker.internet.url(), "/angular.min.js\"></script>");
+  expect(getFrameworks()).toEqual(['AngularJS']);
+});
+test('should detect angular from global ng property', () => {
+  global.ng = {};
+  expect(getFrameworks()).toEqual(['Angular']);
+  delete global.ng;
+});
+test('should detect angular from html [ng-version] property', () => {
+  document.body.innerHTML = '<div ng-version=""></div>';
+  expect(getFrameworks()).toEqual(['Angular']);
+});
+test('should detect backbone from global Backbone property', () => {
+  global.Backbone = {};
+  expect(getFrameworks()).toEqual(['Backbone']);
+  delete global.Backbone;
+});
+test('should detect ember from global Ember property', () => {
+  global.Ember = {};
+  expect(getFrameworks()).toEqual(['Ember']);
+  delete global.Ember;
+});
+test('should detect vue from global Vue property', () => {
+  global.Vue = {};
+  expect(getFrameworks()).toEqual(['Vue']);
+  delete global.Vue;
+});
+test('should detect meteor from global Meteor property', () => {
+  global.Meteor = {};
+  expect(getFrameworks()).toEqual(['Meteor']);
+  delete global.Meteor;
+});
+test('should detect zepto from global Zepto property', () => {
+  global.Zepto = {};
+  expect(getFrameworks()).toEqual(['Zepto']);
+  delete global.Zepto;
+});
+test('should detect jquery from global jQuery property', () => {
+  global.jQuery = {};
+  expect(getFrameworks()).toEqual(['Jquery']);
+  delete global.jQuery;
+});
+test('should detect mootools from global MooTools property', () => {
+  global.MooTools = {};
+  expect(getFrameworks()).toEqual(['MooTools']);
+  delete global.MooTools;
+});